Interview: How to ensure that a thread runs after another?

Question

There are thread T1, T2 and T3, how can we ensure that thread T2 run after T1 and thread T3 run after T2?

This question was asked in my interview. I didn't answer. Please explain in detail.

Answer 1

Here is my approach to the problem using CountDownLatch for signalling .

T1 thread after doing its job signal to T2 and T2 to T3.

public class T1T2T3 {
  public static void main(String[] args) {

    CountDownLatch c1 = new CountDownLatch(1);
    CountDownLatch c2 = new CountDownLatch(1);
    Thread T1 = new Thread(new Runnable() {

      @Override
      public void run() {
        System.out.println("T1");
        c1.countDown();
      }
    });
    Thread T2 = new Thread(new Runnable() {
      @Override
      public void run() {
        //should listen to something from T1
        try {
          c1.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println("T2");
        c2.countDown();
      }
    });
    Thread T3 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          c2.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println("T3");
      }
    });

    T1.start();
    T3.start();
    T2.start();
  }
}

Answer 2

package io.hariom.threading;

//You have three threads T1, T2, and T3, How do you ensure that they finish in order T1, T2, T3 ?

public class ThreadTest1 {

public static void main(String[] args) {

    Thread thread1 = new Thread(new MyRunnable(null));
    Thread thread2 = new Thread(new MyRunnable(thread1));
    Thread thread3 = new Thread(new MyRunnable(thread2));
    thread1.start();
    thread2.start();
    thread3.start();

}

}

class MyRunnable implements Runnable { Thread t;

MyRunnable(Thread t) {
    this.t = t;

}

@Override
public void run() {
    if (t != null) {
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    System.out.println(Thread.currentThread().getName() + " starts");
    try {
        Thread.sleep(10);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println(Thread.currentThread().getName() + " ends");
}

}

Answer 3

There are thread T1, T2 and T3, how can we ensure that thread T2 run after T1 and thread T3 run after T2? OR There are three threads T1, T2 and T3? How do you ensure sequence T1, T2, T3 in Java? The question basically is T3 should finish first , T2 second and T1 last. We can use use join() method of thread class. To ensure three threads execute you need to start the last one first e.g. T3 and then call join methods in reverse order e.g. T3 calls T2.join, and T2 calls T1.join. In this way, T1 will finish first and T3 will finish last.

public class Test1 {
    public static void main(String[] args) {
        final Thread t1 = new Thread(new Runnable() {
            public void run() {
                System.out.println("start 1");
                System.out.println("end 1");
            }//run
        });

        final Thread t2  = new Thread(new Runnable() {
            public void run() {
                System.out.println(" start 2 ");
                try {
                    t1.join(2000);
                } catch (Exception e) {
                    e.getStackTrace();
                }
                System.out.println(" end 2");
            }
        }) ;

        final Thread t3 = new Thread( new Runnable() {
            public void run() {
                System.out.println(" start 3 ");

                try {
                    t2.join(4000);
                }catch(Exception e) {
                    e.getStackTrace();
                }
                System.out.println(" end  3 ");
            }
        });
       // we are reversing the order of the start() method
        t3.start();
        t2.start();
        t1.start();


    }
}

From the output, You can see that threads have started in different order as you don't know which thread will get CPU. Its the decision of the Thread Scheduler, so we cannot do anything. But, you can see that threads are finished in correct order i.e. T1 then T2 and then T3.

There is another way of doing it. The pseudo code is :

t1.start();

    t1.join(); // signals t2 to wait

    if( !t1.isAlive()) {
        t2.start();// if t1 is finished then t2 will start
    }

    t2.join();//signals t3 to wait

    if (!t2.isAlive()) {
        t3.start(); 
    }

Let's take a full program:

 public class Tic implements Runnable{
   public void run() {
       try {
            for (int i = 0; i < 2; i++) {
                  System.out.println("tic");
            }
    } catch (Exception e) {
        // TODO: handle exception
        e.getStackTrace();
    }
   }
}

public class Tac implements Runnable{
       public void run() {
           try {
                for (int i = 0; i < 2; i++) {
                      System.out.println("tac");
                }
        } catch (Exception e) {
            // TODO: handle exception
            e.getStackTrace();
        }
       }
    }
public class Toe implements Runnable{
       public  void run() {
           try {
                for (int i = 0; i < 2; i++) {
                      System.out.println("toe");
                }
        } catch (Exception e) {
            // TODO: handle exception
            e.getStackTrace();
        }
       }
    }

public class RunThreads1 {
public static void main(String[] args) {
    try {

        Tic tic = new Tic();
        Tac tac = new Tac();
        Toe toe = new Toe();
        Thread t1 = new Thread(tic);
        Thread t2 = new Thread(tac);
        Thread t3 = new Thread(toe);
        t1.start();

        t1.join(); // signals t2 to wait

        if( !t1.isAlive()) {
            t2.start();// if t1 is finished then t2 will start
        }

        t2.join();//signals t3 to wait

        if (!t2.isAlive()) {
            t3.start(); 
        }

    }catch(InterruptedException e) {
        e.printStackTrace();
    }
}
}

The output is : tic tic tac tac toe toe

Answer 4

how can we ensure that thread T2 run after T1 and thread T3 run after T2?

NOTE: Assuming that it is not about scheduling the threads in the required order 

We could use the Condition Interface.

We'll need two conditions bound to a single Lock: condition1 to coordinate T1 and T2, condition2 to coordinate T2 and T3.
Pass condition1 to T1 and T2, condition2 to T2 and T3.

So, we would have T2 await on condition1 in it's run method, which will be signalled by T1 (from T1's run method, after T1 starts/finishes its task).

Similarly have T3 await on condition2 in it's run method, which will be signalled by T2 (from T2's run method, after it starts/finishes it's task).

Answer 5

By using join you can ensure running of a thread one after another.

class MyTestThread implements Runnable{

    public void run() {
    System.out.println("==MyTestThread : START : "+Thread.currentThread().getName());
    for(int i = 0; i < 10; i++){
        System.out.println(Thread.currentThread().getName() + " :i = "+i);
    }
    System.out.println("==MyTestThread : END : "+Thread.currentThread().getName());
    }

}
public class ThreadJoinTest {

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new MyTestThread(), "t1");
        Thread thread2 = new Thread(new MyTestThread(), "t2");

        thread1.start();
        thread1.join();
        thread2.start();
        thread2.join();

        System.out.println("====All threads execution===completed");
    }

}

Answer 6

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class Worker implements Runnable {

  BlockingQueue<Integer> q = new LinkedBlockingQueue<>();
  Worker next = null; // next worker in the chain

  public void setNext(Worker t) {
    this.next = t;
  }

  public void accept(int i) {
    q.add(i);
  }

  @Override
  public void run() {
    while (true) {
      int i;
      try {
        i = q.take(); // this blocks the queue to fill-up
        System.out.println(Thread.currentThread().getName() + i);
        if (next != null) {
          next.accept(i + 1); // Pass the next number to the next worker
        }
        Thread.sleep(500); // Just sleep to notice the printing.
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

public class PrintNumbersSequentially {
  public static void main(String[] as) {

    Worker w1 = new Worker();
    Worker w2 = new Worker();
    Worker w3 = new Worker();

    w1.setNext(w2);
    w2.setNext(w3);
    w3.setNext(w1);

    new Thread(w1, "Thread-1: ").start();
    new Thread(w2, "Thread-2: ").start();
    new Thread(w3, "Thread-3: ").start();

    //Till here all the threads have started, but no action takes place as the queue is not filled for any worker. So Just filling up one worker.
    w1.accept(100);
  }
}

I think this could help you out.

Answer 7

package thread;

class SyncPrinter {
    public static void main(String[] args) {
        SyncPrinterAction printAction1 = new SyncPrinterAction(new int[]{1,5,9,13}, true);
        SyncPrinterAction printAction2 = new SyncPrinterAction(new int[]{2,6,10,14}, true);
        SyncPrinterAction printAction3 = new SyncPrinterAction(new int[]{3,7,11,15}, true);
        SyncPrinterAction printAction4 = new SyncPrinterAction(new int[]{4,8,12,16}, false);

    printAction1.setDependentAction(printAction4);
    printAction2.setDependentAction(printAction1);
    printAction3.setDependentAction(printAction2);
    printAction4.setDependentAction(printAction3);

    new Thread(printAction1, "T1").start();;        
    new Thread(printAction2, "T2").start();
    new Thread(printAction3, "T3").start();     
    new Thread(printAction4, "T4").start();



}
}

class SyncPrinterAction implements Runnable {

private volatile boolean dependent;
private SyncPrinterAction dependentAction;
int[] data;

public void setDependentAction(SyncPrinterAction dependentAction){
    this.dependentAction = dependentAction;

}

public SyncPrinterAction( int[] data, boolean dependent) {
    this.data = data;
    this.dependent = dependent;
}

public SyncPrinterAction( int[] data, SyncPrinterAction dependentAction, boolean dependent) {
    this.dependentAction = dependentAction;
    this.data = data;
    this.dependent = dependent;
}

@Override
public void run() {
    synchronized (this) {

        for (int value : data) {

            try {
                while(dependentAction.isDependent())
                    //System.out.println("\t\t"+Thread.currentThread().getName() + " :: Waithing for dependent action to complete");
                wait(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            dependentAction.setDependent(true);

            System.out.println(Thread.currentThread().getName() + " :: " +value);
            dependent = false;
        }

    }

}

private void setDependent(boolean dependent) {
    this.dependent = dependent;

}

private boolean isDependent() {
    return dependent;
}

}

Answer 8

One way to do it would be something like the following. It's complex though. You might want to use the java.util.concurrent.CyclicBarrier class for this.

Each thread when it finishes sets the boolean value and notifies the next thread to continue. Even though it is an AtomicBoolean class, we need the synchronized so we can wait() and notify() on it.

It would be cleaner to pass in the lock objects or maybe have a begin() method on T2 and T3 so we can hide the locks inside of those objects.

final Object lock2 = new Object();
final Object lock3 = new Object();
boolean ready2;
boolean ready3;
...
public T1 implements Runnable {
    public void run() {
        ...
        synchronized (lock2) {
            // notify the T2 class that it should start
            ready2 = true;
            lock2.notify();
        }
    }
}
...

public T2 implements Runnable {
    public void run() {
        // the while loop takes care of errant signals
        synchronized (lock2) {
            while (!ready2) {
                lock2.wait();
            }
        }
        ...
        // notify the T3 class that it should start
        synchronized (lock3) {
            ready3 = true;
            lock3.notify();
        }
    }
}
...
public T3 implements Runnable {
    public void run() {
        // the while loop takes care of errant signals
        synchronized (lock3) {
            while (!ready3) {
                lock3.wait();
            }
        }
        ...
    }
}

Answer 9

The concurrent package has better classes to use the shared object. One of the way is like this.

public static void main(String[] args) {

    final Lock lock = new ReentrantLock();
    final Condition condition = lock.newCondition();

    ThreadId threadId = new RunInSequence.ThreadId();
    threadId.setId(1);
    Thread t1 = setThread("thread1",lock, condition, 1, 2, threadId);
    Thread t2 = setThread("thread2",lock, condition, 2, 3, threadId);
    Thread t3 = setThread("thread3",lock, condition, 3, 1, threadId);
    t1.start();
    t2.start();
    t3.start();

}

private static class ThreadId {
    private int id;

    public ThreadId() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

private static Thread setThread(final String name,final Lock lock, final Condition condition, int actualThreadId, int nextThreadId,
        ThreadId threadId) {
    Thread thread = new Thread() {
        @Override
        public void run() {
            while (true) {
                lock.lock();
                try {
                    while (threadId.getId() != actualThreadId) {
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(name+"prints: " + actualThreadId);
                    threadId.setId(nextThreadId);
                    condition.signalAll();
                } finally {
                    lock.unlock();
                }
            }
        }
    };
    return thread;
}

Answer 10

Guess what interviewer asking was three threads do the work in sequence.For example if one thread prints 1,4,5...second 2,5,8 and thirds 3,6,9 etc..ur output should be 1,2,3,4,5..... Ist thread prints 1 and gives chance to 2nd thread to print 2..etc.,

I tried it using cyclebarriers.As soon as 'one' prints 1it gives chance to two as it calls cb.wait,when two runs it will in turn call three in similar fashion and it will continue.Let me know if thr are any bugs in the code

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

class one implements Runnable{
    CyclicBarrier cb;
    one(CyclicBarrier cb){this.cb=cb;}
    public void run(){
        int i=1;
        while(true)
        {
            System.out.println(i);
            try {
                Thread.sleep(1000);
                cb.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            i=i+3;
        }
    }

}
class two implements Runnable{
    CyclicBarrier cb;
    int i=2;
    two(CyclicBarrier cb){this.cb=cb;}
    public void run(){


        System.out.println(i);
        try {
            cb.await();
            i=i+3;
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}


public class oneTwoThree {
    public static void main(String args[]){
        Runnable threePrinter = new Runnable() {
            int i=3;
            public void run() {
                System.out.println(i);
                i=i+3;
            }
        };


        CyclicBarrier bar2 =new CyclicBarrier(1,threePrinter);//, barrier1Action);
        two twoPrinter  =new two(bar2);
        CyclicBarrier bar1 =new CyclicBarrier(1,twoPrinter);

        Thread onePrinter=new Thread(new one(bar1));
        onePrinter.start();
    }
}

Answer 11

I tried in a much simpler way.. using a waits and notifies.(as opposed to cyclic barrier approach in my prev post).

It uses a 'State' class... which gets three states:1,2,3.(default 3). When it is at 3, it triggers t1, at 1 will trigger t2, at 2 will trigger t3 and so on.

Classes: State// int i=3 T1// prints 1,4,7... T2// Prints 2,5,8 T3//Prints 3,6,9 etc.,

Please let me know your views or if any issues in the code. Thanks.

Here is the code.:

public class State {

    private int state ;

    public State() {
        this.state =3;
    }

    public synchronized int getState() {
        return state;
    }

    public synchronized void setState(int state) {
        this.state = state;
    }


}


public class T1 implements Runnable {

    State s;
    public T1(State s) {
        this.s =s;
    }

    @Override
    public void run() {
        int i =1;

        while(i<50)
        {
            //System.out.println("s in t1 "+ s.getState());

            while(s.getState() != 3)
            {

                synchronized(s)
                {
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }

            }

            synchronized(s)
            {
                //if(s.getState() ==3)

                if(s.getState()==3)
                System.out.println("t1 "+i);
                s.setState(1);
                i = i +3 ;
                s.notifyAll();


            }

        }

    }

}




public class T2 implements Runnable {

    State s;
    public T2(State s) {
        this.s =s;
    }

    @Override
    public synchronized void run() {
        int i =2;

        while(i<50)
        {

            while(s.getState() != 1)
            {

                synchronized(s)
                {
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }

            }

            synchronized(s)
            {
                //if(s.getState() ==3)

                if(s.getState()==1)
                System.out.println("t2 "+i);
                s.setState(2);
                i = i +3 ;
                s.notifyAll();

            }

        }




    }


}



public class T3 implements Runnable {

    State s;
    public T3(State s) {
        this.s =s;
    }

    @Override
    public synchronized void run() {
        int i =3;

        while(i<50)
        {

            while(s.getState() != 2)
            {
                synchronized(s)
                {
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }

            }

            synchronized(s)
            {

                if(s.getState()==2)
                System.out.println("t3 "+i);
                i = i +3 ;
                s.setState(3);
                s.notifyAll();
            }

        }



    }}





    public class T1t2t3 {
        public static void main(String[] args) {

            State s = new State();
            Thread t1 = new Thread(new T1(s));
            Thread t2 = new Thread(new T2(s));
            Thread t3 = new Thread(new T3(s));

            t1.start();
            t2.start();
            t3.start();

        }
    }

Answer 12

Try the below code while using that you can run n number of thread in that manner.

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CyclicExecutionOfThreads {

    public static void main(String args[]) {

        int totalNumOfThreads = 10;
        PrintJob printJob = new PrintJob(totalNumOfThreads);

        /*
        MyRunnable runnable = new MyRunnable(printJob, 1);
        Thread t1 = new Thread(runnable);

        MyRunnable runnable2 = new MyRunnable(printJob, 2);
        Thread t2 = new Thread(runnable2);

        MyRunnable runnable3 = new MyRunnable(printJob, 3);
        Thread t3 = new Thread(runnable3);

        t1.start();
        t2.start();
        t3.start();
        */

        //OR

        ExecutorService executorService = Executors
                .newFixedThreadPool(totalNumOfThreads);
        Set<Runnable> runnables = new HashSet<Runnable>();

        for (int i = 1; i <= totalNumOfThreads; i++) {
            MyRunnable command = new MyRunnable(printJob, i);
            runnables.add(command);
            executorService.execute(command);
        }

        executorService.shutdown();

    }
}

class MyRunnable implements Runnable {

    PrintJob printJob;
    int threadNum;

    public MyRunnable(PrintJob job, int threadNum) {
        this.printJob = job;
        this.threadNum = threadNum;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (printJob) {
                if (threadNum == printJob.counter) {
                    printJob.printStuff();

                    if (printJob.counter != printJob.totalNumOfThreads) {
                        printJob.counter++;
                    } else {

                        System.out.println();
                        // reset the counter
                        printJob.resetCounter();

                    }

                    printJob.notifyAll();

                } else {
                    try {
                        printJob.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }

}

class PrintJob {
    int counter = 1;
    int totalNumOfThreads;

    PrintJob(int totalNumOfThreads) {
        this.totalNumOfThreads = totalNumOfThreads;
    }

    public void printStuff() {
        System.out.println("Thread " + Thread.currentThread().getName()
                + " is printing");

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public void resetCounter() {
        this.counter = 1;
    }
}

Answer 13

Use the thread isAlive method before starting the thread T2 and T3.

Thread t1 = new Thread(new T1()); 
Thread t2 = new Thread(new T2()); 
Thread t3 = new Thread(new T3()); 
t1.start();

if(t1.isAlive()){   

    t2.start();

}

if(t2.isAlive()){

    t3.start();
}

Answer 14

The obvious, and simplest, way has already been posted by @Assylias - have T1 run method create/start T2 and T2 run method create/start T3.

It is, IMHO, verging on pointless, but it could be done.

Solutions using Join() do not answer the question - they ensure that the termination of the threads is ordered, not the running of them. If the interviewr does not get that, you need to find another job anyway.

In an interview, my answer would be 'For * sake why? Threads are ususally used to avoid exactly what you are asking!'.

Answer 15

Threads are also runnables. You can simply run them sequentially:

t1.run();
t2.run();
t3.run();

This has obviously little interest.

Assuming they want the threads to run in parallel, one solution would be to have each thread start the next one, since the JMM guarantees that:

A call to start() on a thread happens-before any actions in the started thread.

Answer 16

This would be the simplest, dumbest approach:

final Thread t1 = new Thread(new T1()); // assume T1 is a Runnable
t1.start();
t1.join();
final Thread t2 = new Thread(new T2());
t2.start();
t2.join();
final Thread t3 = new Thread(new T3());
t3.start();
t3.join();

Answer 17

At the start of each thread (except t1), make it call join() on it's predecessor. Using executors (instead of threads directly) is another option. One could also look at using semaphores - T1 should release the permit upon completion, T2 should try to acquire two permits, and release them when done, T3 should try to acquire three permits & so on. Using join or executors would be the preferred route.

Answer 18

Create a priority queue with each tread in the other they are created. You can then apply Thread.join after it completes, remove that thread from the priority queue, and then execute the first element of the queue again. Pseudocode:

   pthread [3] my_threads
    my_queue
    for t in pthreads:
         my_queue.queue(t)

   while !my_queue.empty()
      pop the head of the queue
      wait until it complets
      thread.join()

implementation is left as exercise, so next time you get it right!