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

Question

我正在尝试为 Java 中的多线程问题编写我的解决方案：

创建三个单独的线程来计算平均值、最小值 以及传递给程序的一系列数字中的最大值。这 值将全局存储在程序中。这三个线程将 将这三个值分别返回到主程序中 输出给用户。

我是 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.");
       }
}

我不确定如何创建执行单独功能的线程：计算双精度、最小值和最大值。到目前为止，我已经创建了一个线程来计算平均值并将其返回给主程序。这是我的代码 [直到现在]：

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 块中调用 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();

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

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

当然，在这种情况下，您的班级都没有这样做，但要记住这一点。

例如

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();

Answer 2

在@ElvenAshwin 回答的基础上，您可能应该将三个类作为私有内部类.... 构建更大的东西时不会污染公共API 的良好做法。作为一个替代的很好的练习，考虑在 java 8 中使用 lambdas 来做。它只是一个你不需要类的函数。