java - 在 Java 中创建三个线程来计算三个不同的项目

Question

我正在尝试针对 Java 中的多线程问题编写解决方案:

Create three separate threads that will calculate the average, minimum and maximum of a series of numbers that is passed to the program. The values will be stored globally in the program. The three threads will return the three values respectively to the main program where it will be output to the user.

我是 Java 的新手，所以我有一个关于这个程序的方法的基本问题:如何创建三个独立的线程来执行三个不同的功能?在阅读多线程时，我遇到了几个例子，其中创建了三个(或更多)线程，每个线程执行一个函数:counting down a loop .因此只需要一次调用 public void run()并且可以很容易地创建一个实现 Runnable 的类的三个实例来执行此操作，例如:

// Create multiple threads.
       class NewThread implements Runnable {
         String name; // name of thread
         Thread t;
         NewThread(String threadname) {
           name = threadname;
           t = new Thread(this, name);
           System.out.println("New thread: " + t);
           t.start(); // Start the thread
}
         // This is the entry point for thread.
         public void run() {
          try {
             for(int i = 5; i > 0; i--) {
               System.out.println(name + ": " + i);
               Thread.sleep(1000);
             }
           } catch (InterruptedException e) {
             System.out.println(name + "Interrupted");
}
           System.out.println(name + " exiting.");
         }
}

  class MultiThreadDemo {
       public static void main(String args[]) {
         new NewThread("One"); // start threads
         new NewThread("Two");
         new NewThread("Three");
         try {
           // wait for other threads to end
           Thread.sleep(10000);
         } catch (InterruptedException e) {
           System.out.println("Main thread Interrupted");
}
         System.out.println("Main thread exiting.");
       }
}

我不确定如何创建执行不同功能的线程:计算 double 、最小值和最大值。到目前为止，我已经创建了一个计算平均值并将其返回到主程序的线程。这是我的代码 [到目前为止]:

package assignment2;
class Q2Thread implements Runnable {


    String name;
    Thread t;
    private int average;
    int sum=0;

    Q2Thread(String name)
    {
        this.name=name;
        t=new Thread(this, name);
        //System.out.println("This thr");
        t.start();
    }

    public void run()
    {
        try
        {
            for(int i=0;i<Q7Main.arr.length;i++)
                sum+=Q7Main.arr[i];

            average=sum/Q7Main.arr.length;



        }
        //catch(InterruptedException e)
        finally
        {
            System.out.println("Calcuated average.");
        }

    System.out.println("Child Thread exiting.");
    }

    public int getAverage() 
    {
        return average;
    }

}

package assignment2;
import java.util.*;
public class Q7Main {

     public static int[] arr=new int[5];

    static Scanner in=new Scanner(System.in);
    private static int finalAverage;


    public static void main(String[] args) {
        // TODO Auto-generated method stub


        System.out.println("Please enter the numbers: " );
        for(int i=0;i<arr.length; i++)
            arr[i]=in.nextInt();
        System.out.println("You entered the numbers: ");
        for(int x: arr)
            {
            System.out.print(x+ " ");
            }
        System.out.println();

        Q2Thread obj=new Q2Thread("Average");

        try
        {
            obj.t.join();
        }
        catch(InterruptedException e)
        {
            System.out.println("Interrupted.");
        }

        finalAverage=obj.getAverage();
        System.out.println("The average of the numbers is: "+ finalAverage);
    }

}

我现在有两个问题:

1. 谁能告诉我创建两个线程来计算最小值和最大值的方法？
2. 我的代码(到目前为止)是否有任何我应该注意的 OOP 缺陷？

Answer 1

你可以做的是创建另外两个计算最小值和最大值的类，为它们分别创建一个对象 obj1 和 obj2。由于构造函数为您启动线程，您现在应该有 3 个异步运行的线程。

在该 try block 中调用 obj1.t.join() 和 obj2.t.join()。所以它应该是这样的:

   try{
        obj.t.join();
        obj1.t.join();
        obj2.t.join();
   }
   catch(InterruptedException e)
   {
       System.out.println("Interrupted.");
   } 
   int average = obj.getAverage();
   int max = obj1.getMax();
   int min = obj2.getMin();

然后用这些数字做任何你想做的事。

至于一些一般性的评论，首先我不会将线程对象作为可运行类中的属性，也不会在构造函数中使用 start() 方法。相反，在主类中，我鼓励您使用每个可运行类的一个实例创建三个线程对象，然后在每个对象上调用 start() 方法。此外，而不是三个可运行的 所有类都与 Q7Main 中的同一个静态数组交互，我会改为更新它们 构造函数接受数组作为构造函数中的参数，然后在调用它们的 run 方法时让它们中的每一个都与唯一的数组对象进行交互。否则，您会遇到一个问题，即当一个线程更改数组中某些内容的值时，您会得到意想不到的结果。

当然，在这种情况下，您的所有类(class)都不会这样做，但请记住这一点。

例如

Q2Thread obj =new Q2Thread("Average", arr);
Q2MaxThread obj1 = new Q2MaxThread("Maximum", arr);
Q2MinThread obj2 = new Q2MinThread("Minimum", arr);
Thread avThread = new Thread(obj);
Thread maxThread = new Thread(obj1);
Thread minThread= new Thread(obj2);

avThread.start();
maxThread.start();
minThread.start();

   try{
        avThread.join();
        maxThread.join();
        minThread.join();
   }
   catch(InterruptedException e)
   {
       System.out.println("Interrupted.");
   } 
   int average = obj.getAverage();
   int max = obj1.getMax();
   int min = obj2.getMin();