Java MultiThreading对象

Question

我正在尝试在java中为一些算法建模，我现在面临的是我需要运行算法的主体10次，但这个过程需要120分钟才能完成，所以我在一个线程上运行。我想要的是创建10个线程，而不是在每个线程中重复相同的代码，那么如何使用相同的代码来执行10个不同的线程。任何想法。

package biodavidcorne;

import java.util.Random;

/**
 *
* @author hyder
 */
public class BIODavidCorne extends Thread {

public void run(int Runs) {
}

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {


    BIODavidCorne test = new BIODavidCorne();
    Thread t1 = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                int Runs = 0;
                int[][] Mean10Runs = new int[10][10000];
                int[][] Min10Runs = new int[10][10000];
                int[][] Max10Runs = new int[10][10000];




                //   for (int Runs = 0; Runs < 10; Runs++) {
                BinList test = new BinList();
                Random generator = new Random();
                for (int i = 0; i < 10; i++) {
                    test.ReadLine("File.txt", i);
                }

                //test.PrintListOfGarbage();
                for (int i = 0; i < 10; i++) {
                    test.InsertGarbageToBin(i);
                }
                for (int Big = 0; Big < 10000; Big++) {
                    int Mean = 0;
                    for (int x = 0; x < 10; x++) {
                        for (int i = 0; i < 50; i++) {
                            test.GetPenalties(x, i);
                        }
                    }
                    //     System.out.println("*******************************************************************************************" + Big + " .. " + Runs);
                    // test.PrintListOfGarbage();
                    int[] penalty = new int[10];
                    int[] minimum = new int[10];
                    int[] maximum = new int[10];
                    int[] mutation = new int[10];
                    //    test.PrintListOfGarbage();
                    for (int i = 0; i < 10; i++) {
                        penalty[i] = test.getAllPanalties(i);
                    }

                    for (int i = 0; i < 10; i++) {
                        minimum[i] = test.getMinimum(i);
                        maximum[i] = test.getMaximum(i);
                        mutation[i] = test.calculateMutation(penalty[i], minimum[i], maximum[i]);
                        // 

                    }

                    int r = generator.nextInt(10);
                    int s = generator.nextInt(10);
                    test.MakeTheFitness(mutation, r, s);
                    test.resetPenaltyArray();
                    // test.PrintListOfGarbage();
                    for (int i = 0; i < 10; i++) {
                        Mean = Mean + mutation[i];

                    }
                    int min = mutation[0];
                    int max = 0;
                    for (int i = 0; i < 10; i++) {

                        if (min > mutation[i]) {
                            min = mutation[i];
                        }
                        if (max < mutation[i]) {
                            max = mutation[i];
                        }
                    }
                    Min10Runs[Runs][Big] = min;
                    Max10Runs[Runs][Big] = max;
                    Mean10Runs[Runs][Big] = (Mean / 10);
                    System.out.println("This is the Mean 1"+Big+".."+Runs);

                }

                System.out.println("This is the Mean + for Runs" + Runs + ".. " + Mean10Runs[Runs][9999] + "This is the Minimum " + Min10Runs[Runs][9999]);


            } catch (Exception e) {
                System.out.println("Not supported yet." + e);
            }

        }
    });
    Thread t2 = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                int Runs = 0;
                int[][] Mean10Runs = new int[10][10000];
                int[][] Min10Runs = new int[10][10000];
                int[][] Max10Runs = new int[10][10000];




                //   for (int Runs = 0; Runs < 10; Runs++) {
                BinList test = new BinList();
                Random generator = new Random();
                for (int i = 0; i < 10; i++) {
                    test.ReadLine("File.txt", i);
                }

                //test.PrintListOfGarbage();
                for (int i = 0; i < 10; i++) {
                    test.InsertGarbageToBin(i);
                }
                for (int Big = 0; Big < 10000; Big++) {
                    int Mean = 0;
                    for (int x = 0; x < 10; x++) {
                        for (int i = 0; i < 50; i++) {
                            test.GetPenalties(x, i);
                        }
                    }
                    //  System.out.println("*******************************************************************************************" + Big + " .. " + Runs);
                    // test.PrintListOfGarbage();
                    int[] penalty = new int[10];
                    int[] minimum = new int[10];
                    int[] maximum = new int[10];
                    int[] mutation = new int[10];
                    //    test.PrintListOfGarbage();
                    for (int i = 0; i < 10; i++) {
                        penalty[i] = test.getAllPanalties(i);
                    }

                    for (int i = 0; i < 10; i++) {
                        minimum[i] = test.getMinimum(i);
                        maximum[i] = test.getMaximum(i);
                        mutation[i] = test.calculateMutation(penalty[i], minimum[i], maximum[i]);
                        // 

                    }

                    int r = generator.nextInt(10);
                    int s = generator.nextInt(10);
                    test.MakeTheFitness(mutation, r, s);
                    test.resetPenaltyArray();
                    // test.PrintListOfGarbage();
                    for (int i = 0; i < 10; i++) {
                        Mean = Mean + mutation[i];

                    }
                    int min = mutation[0];
                    int max = 0;
                    for (int i = 0; i < 10; i++) {

                        if (min > mutation[i]) {
                            min = mutation[i];
                        }
                        if (max < mutation[i]) {
                            max = mutation[i];
                        }
                    }
                    Min10Runs[Runs][Big] = min;
                    Max10Runs[Runs][Big] = max;
                    Mean10Runs[Runs][Big] = (Mean / 10);
                    System.out.println("This is the Mean 2"+Big+".."+Runs);

                }



            } catch (Exception e) {
                System.out.println("Not supported yet." + e);
            }

        }
    });
    t1.start();
    t2.start();
}

}

Answer 1

只需将Runnable设置为命名类，而不是匿名内部类，然后重用它：

class MyRunnable implements Runnable {
    @Override
    public void run() {
       int Runs = 0;
       int[][] Mean10Runs = new int[10][10000];
    // ...

new Thread(new MyRunnable()).start();

您可以(也应该)将MyRunnable放入它自己的源文件中。

Answer 2

没有理由复制和粘贴匿名内部类的内容十次。只需将其赋给一个变量并使用10次即可。

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        // ... the code in the anonymous inner class
    }
}

// Start 10 threads with this code
for (int i = 0; i < 10; ++i) {
    new Thread(runnable).start();
}

Answer 3

您可以使用for循环来创建线程。此外，如果您希望确保所有线程同时启动，则可以使用CyclicBarrier，但如果不是这样，则可以在创建线程时启动每个线程。

如果需要保存对线程的引用，请将它们存储在Thread数组中

CyclicBarrier barrier = new CyclicBarrrier(10);

// Runnable runnable = ...你的代码。在Runnable的开头放入第一行barrier.await()；//并捕获异常

Thread[] threads = new Thread[10];
for(int i = 0; i < 10; i++){
  threads[i] = new Thread(runnable);
  threads[i].start();
}

就这样!祝您好运-如果您需要实现runnable的帮助，请告诉我