Question

I use Thread in Java. I create a class that extend Thread and it’s fine, but the problem is, when call this Thread, I don’t know the number of instances of this class, since the user must enter this number. For example:

multiThread multiThreadInstance = new multiThread(/* number entered from user */);
multiThreadInstance.start();  

This will call this thread once, but if i write:

multiThread multiThreadInstance1 = new multiThread(/* number entered from user */)
multiThreadInstance1.start()   
multiThread multiThreadInstance2 = new multiThread(/* number entered from user */)
multiThreadInstance2.start()  

This will call it twice at the same time, and so on.

If I put it in a for loop, then if user enters 3 for example, then start1 runs, when start1 finishes, start2 runs, when start2 finishes, start3 runs. I need to keep these instances of thread running in at the same time. How can i do this?

Answer 1

You need to use java high level concurrency utilities to do this. Look at countdownlatches and executors. The following is a code that would do what you want. I recommend you read up on java concurrency utilities.

import java.util.concurrent.*;

public class ConcurrentTimer {
    private ConcurrentTimer() { } // Noninstantiable

    public static long time(Executor executor, int concurrency,
            final Runnable action) throws InterruptedException {
        final CountDownLatch ready = new CountDownLatch(concurrency);
        final CountDownLatch start = new CountDownLatch(1);
        final CountDownLatch done = new CountDownLatch(concurrency);

        for (int i = 0; i < concurrency; i++) {
            executor.execute(new Runnable() {
                public void run() {
                    ready.countDown(); // Tell timer we're ready
                    try {
                        start.await(); // Wait till peers are ready
                        action.run();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } finally {
                        done.countDown();  // Tell timer we're done
                    }
                }
            });
        }

        ready.await();     // Wait for all workers to be ready
        long startNanos = System.nanoTime();
        start.countDown(); // And they're off!
        done.await();      // Wait for all workers to finish
        return System.nanoTime() - startNanos;
    }
}

---

A runnable version of the code example provided above: (Edited)

import java.util.concurrent.*;

public class ConcurrentTimer {

    public static void main(String[] args) {


        try {
            Runnable action = new Runnable() {
                    public void run() {

                        System.out.println("Thread Running");

                    }
                };

            time (3, action);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    private ConcurrentTimer() { } // Noninstantiable

    public static long time(int concurrency,
            final Runnable action) throws InterruptedException {

        Executor executor = Executors.newFixedThreadPool(concurrency);


        final CountDownLatch ready = new CountDownLatch(concurrency);
        final CountDownLatch start = new CountDownLatch(1);
        final CountDownLatch done = new CountDownLatch(concurrency);

        for (int i = 0; i < concurrency; i++) {
            executor.execute(new Runnable() {
                public void run() {
                    ready.countDown(); // Tell timer we're ready
                    try {
                        start.await(); // Wait till peers are ready
                        action.run();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } finally {
                        done.countDown();  // Tell timer we're done
                    }
                }
            });
        }

        ready.await();     // Wait for all workers to be ready
        long startNanos = System.nanoTime();
        start.countDown(); // And they're off!
        done.await();      // Wait for all workers to finish
        return System.nanoTime() - startNanos;
    }
}