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

我不确定如何创建执行单独功能的线程：计算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);
    }

}

我现在有两个问题：

有人能给我创建两个计算最小和最大的线程的方法吗？
我的代码（到目前为止）是否有任何我应该注意的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();

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

至于一些一般性注释，首先我不会在runnable类中有一个线程对象作为属性，在构造函数中也没有start()方法。相反，在主类中，我鼓励您使用每个可运行类的实例创建三个线程对象，然后在每个对象上调用start()方法。而且，而不是三个runnable 所有类都与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。它只是一个你不需要的类。

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

2 个答案: