Interview Question

Java program for printing sequence using 3 threads | How to run three threads sequentially in Java

Deepanshu Jain

Solution

Here is the core logic to write program for sequence using three threads. We will use concept of remainder here.

• If number%3 == 1 then T1 will print the number and increment it else will go in the wait state.
• If number%3 == 2 then T2 will print the number and increment it else will go in the wait state.
• If number%3 == 0 then T3 will print the number and increment it else will go in the wait state.

Code

Step 1: Create a thread class by extending runnable

1. Create thread class by implementing Runnable interface
2. create variable to store number and remainder
3. Create an object called lock for purpose of synchronization between multiple threads.
4. Override run method, wait until the remainder is equal to the remainder of your sequence thread class, put a wait on the lock object
5. Once the condition met
   1. Print the number
   2. increment the number
   3. notify every thread who has a wait on a lock
      

public class PrintSequenceRunnable implements Runnable{
 
    public int PRINT_NUMBERS_UPTO=10;
    static int  number=1;
    int remainder;
    static Object lock=new Object();
 
    PrintSequenceRunnable(int remainder)
    {
        this.remainder=remainder;
    }
 
    @Override
    public void run() {
        while (number < PRINT_NUMBERS_UPTO-1) {
            synchronized (lock) {
               while (number % 3 != remainder) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
              System.out.println(Thread.currentThread().getName() + " " + number);
              number++;
              lock.notifyAll();
            }
        }
    }
}

Step 2: Main class to create 3 threads

Each thread will have remainder, and will be responsible for printing numbers whose remainder from 3 will match.

public class PrintThreadsSequentiallyMain {
 
    public static void main(String[] args) {
 
        PrintSequenceRunnable runnable1=new PrintSequenceRunnable(1); 
        PrintSequenceRunnable runnable2=new PrintSequenceRunnable(2);
        PrintSequenceRunnable runnable3=new PrintSequenceRunnable(0);
 
        Thread t1=new Thread(runnable1,"T1");
        Thread t2=new Thread(runnable2,"T2");
        Thread t3=new Thread(runnable3,"T3");
 
        t1.start();
        t2.start();
        t3.start();   
    }
}

Summary

• This will help you understand the concept of lock, wait and notify for threads.
• The synchronized keyword is to make sure only one thread will have access to lock object at a time.

Complete source code is available here.

[Code reference]