Java MultiThreading objects

Question

I am trying to do a modelling for some algorithms in java, what i am facing now is i need to run the main of the algorithm 10 times but the process takes 120 minutes to finish so i am doing each run on a thread. What i want is to create 10 threads without repeating the same code in each thread so how to make 10 different threads with the same code to excute. any ideas.

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

}

As far as I can see, you algorithm is CPU-intensive, so make sure you have at least 10 cores available before tackling this. — Alexander Pavlov
– Alexander Pavlov, Commented Feb 24, 2012 at 14:07
10 threads running 1 instance of the algorithm is going to take more time than 1 thread running 10 instances of the algorithm sequentially, unless the JVM is able to take advantage of multiple cores. Without knowing the architecture of your program, it is not really possible to suggest any changes that might give you a speed improvement. — mcfinnigan
– mcfinnigan, Commented Feb 24, 2012 at 14:11
I'd move the memory allocation out of the inner loop, e.g. declare penalty, minimum, maximum, etc. outside the for loop and just zero them at the start of each iteration. That will probably speed up serial or threaded code. — andrewmu
– andrewmu, Commented Feb 24, 2012 at 14:12
@mcfinnigan - modern JVMs are pretty good at doing threading over multiple cores. Java is sometimes used for high performance tasks. — andrewmu
– andrewmu, Commented Feb 24, 2012 at 14:15
@andrewmu not a domain I'm familiar with, so I wasn't sure whether the JVM needed -X or -XX args passed to enable multicore use. — mcfinnigan
– mcfinnigan, Commented Feb 24, 2012 at 14:18

Ernest Friedman-Hill · Accepted Answer · 2012-02-24 14:09:18Z

4

Just make the Runnable a named class instead of an anonymous inner class, and reuse it:

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

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

You can (and should) put MyRunnable in its own source file.

answered Feb 24, 2012 at 14:09

Ernest Friedman-Hill

81.9k11 gold badges158 silver badges192 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Jesper · Accepted Answer · 2012-02-24 14:10:33Z

1

There is no reason to copy and paste the content of the anonymous inner class ten times. Just assign it to a variable and use it 10 times.

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

answered Feb 24, 2012 at 14:10

Jesper

208k47 gold badges325 silver badges361 bronze badges

Comments

Victor Grazi · Accepted Answer · 2012-02-24 14:13:57Z

1

You can use a for loop to create the threads. Also, if you want to ensure that all of the threads kick off at the same time, you can use a CyclicBarrier, but if not you can just start each thread as you create it.

If you need to hold a reference to the threads, store them in a Thread array

CyclicBarrier barrier = new CyclicBarrrier(10);

// Runnable runnable = ... your code. at the beginning of the Runnable put the first line barrier.await(); // and catch the exception

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

That's it! Good luck - let me know if you need help implementing the runnable

answered Feb 24, 2012 at 14:13

Victor Grazi

16.6k15 gold badges69 silver badges98 bronze badges

Comments

Paulo Fidalgo · Accepted Answer · 2012-02-24 14:21:46Z

1

Unless you have 10 CPU cores do not spawn 10 threads.

You can use commons threadpool and set it the size of the number of cpu cores, so you can run the tasks in parallel and sequentially.

answered Feb 24, 2012 at 14:21

Paulo Fidalgo

22.4k7 gold badges105 silver badges121 bronze badges

Comments

Louis Q · Accepted Answer · 2012-02-24 14:12:21Z

0

try using a ThreadPoolExecutor

http://docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/ThreadPoolExecutor.html

answered Feb 24, 2012 at 14:12

Louis Q

1762 silver badges7 bronze badges

Comments

Sly · Accepted Answer · 2012-02-24 14:14:13Z

0

Create a class that extends Thread and implement the run method. You could pass argument through the constructor, keep them as members to use them in the run() method.

Something like this:

public class YourThread extends Thread{

    private String mParam1;
    private Object mParam2;

    public YourThread( String param1, Object param2 ){
        mParam1 = param1;
        mParam2 = param2;
    }

    public void run(){
        // do your stuff here
        // ...
    }

}

In the other class:

YourThread t1 = new Thread( "toto", new Object() );
t1.start();

YourThread t2 = new Thread( "titi", new Object() );
t2.start();

answered Feb 24, 2012 at 14:14

Sly

2,1015 gold badges22 silver badges28 bronze badges

Collectives™ on Stack Overflow

Java MultiThreading objects

6 Answers 6

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related