Running the more than two threads in a particular order

Question

I want the threads to run in a particular order. Suppose I have three thread T1, T2, T2 .

T1 prints 0
T2 prints 1
T3 prints 2

I want the output in the order 0 1 2, 0 1 2 for certain number of time.

If there are two threads T1 and T2. Printing 0 1, 0 1... can be done using Producer-Consumer Problem using synchronization.

Answer 1

Create a class UnitOfWork:

public class UnitOfWork implements Runnable
{
    String text;

    public UnitOfWork(String text){
        this.text = text;
    }

    public void run(){
        System.out.println(text);
    }
}

And then create a single thread executor service:

ExecutorService executor = ExecutorService.newSingleThreadExecutor();

which you will use like this:

UnitOfWork uow0 = new UnitOfWork("0");
UnitOfWork uow1 = new UnitOfWork("1");
UnitOfWork uow2 = new UnitOfWork("2");

for(int i = 0; i < 5; i++){
    executor.submit(uow0);
    executor.submit(uow1);
    executor.submit(uow2);
}

When you are unhappy with the single thread, you can start using multiple thread executor service, which will in fact run tasks concurrently.

Answer 2

Using the method join() in the thread class you can achieve this.

The join method allows one thread to wait for the completion of another. If t is a Thread object whose thread is currently executing,

t.join();

causes the current thread to pause execution until t's thread terminates. Overloads of join allow the programmer to specify a waiting period. However, as with sleep, join is dependent on the OS for timing, so you should not assume that join will wait exactly as long as you specify.

Like sleep, join responds to an interrupt by exiting with an InterruptedException.

Answer 3

Use Thread.join to ensure it terminates before the next thread starts.

public static void main(String[] args) throws InterruptedException {
        final Thread th1 = new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("Thread 1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread th2 = new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("Thread 2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread th3 = new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("Thread 3");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        th1.start();
        th1.join();
        th2.start();
        th2.join();
        th3.start();
    }

Answer 4

This is a minimalist piece of code which does literally what you asked for. It relies on the wait-notify mechanism.

I stand by my assesment that you do not need any threads to meet your requirement. A simple loop which prints 0-1-2 is all you really need.

import static java.lang.Thread.currentThread;

public class A {
  static int coordinator, timesPrinted;
  static final int numThreads = 3, timesToPrint = 300;
  public static void main(String[] args) {
    for (int i = 0; i < numThreads; i++) {
      final int myId = i;
      new Thread(new Runnable() { public void run() {
        while (true) synchronized (A.class) {
          if (coordinator%numThreads == myId) {
            System.out.println(myId+1);
            coordinator++;
            if (timesPrinted++ > timesToPrint) currentThread().interrupt();
            A.class.notifyAll();
          }
          try {A.class.wait();} catch (InterruptedException e) {break;}
        }
      }}).start();
    }
  }
}