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

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

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

我是Java新手，所以我有一个关于这个程序方法的基本问题：如何创建三个单独的线程来执行三个不同的函数？在阅读多线程时，我遇到了几个例子，其中创建了三个（或更多）线程，每个线程将执行一个函数：

倒计时循环

。因此，只需对

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、min和max。到目前为止，我已经创建了一个线程来计算平均值并将其返回主程序。这是我的密码[至今]：

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

}

包分配2；
类Q2Thread实现可运行{
字符串名；
螺纹t；
私人整数平均数；
整数和=0；
Q2线程（字符串名称）
{
this.name=name；
t=新螺纹（此，名称）；
//System.out.println（“本thr”）；
t、 start（）；
}
公开募捐
{
尝试
{
对于（int i=0；i您可以创建另外两个计算min和max的类，分别为它们创建一个对象
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();

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

至于一些一般性的评论，首先，我不会在runnable类中使用thread对象作为属性，也不会在构造函数中使用
start（）
方法。相反，在main类中，我建议您创建三个thread对象，每个runnable类都有一个实例，然后调用
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();

除了@ElvenAshwin的答案，你可能应该把三个类作为私有的内部类……当你构建更大的东西时，最好不要污染公共api。作为一个替代的好练习，考虑在java 8中使用lambdas。这只是一个函数，你不需要这个类