The only guide you’ll need on concurrency & multithreading for senior engineers. Pressure test your skills with real-world practice problems from top companies.

Concurrency in Java is one of the most complex and advanced topics brought up during senior engineering interviews. Knowledge of concurrency and multithreading can put interviewees at a considerable advantage. This course lays the foundations of advanced concurrency and multithreading and explains concepts such as Monitors and Deferred Callbacks in depth. It also builds simple and complete solutions to popular concurrency problems that can be asked about in interviews like the Reader-Writer Problem and the Dining Philosopher Problem. While prior knowledge of concurrency is not required to follow through with this course, familiarity with the very basics of concurrency would be helpful.

Java Multithreading for Senior Engineering Interviews

# Problem Statement

Suppose there are three threads t1, t2 and t3. t1 prints **First**, t2 prints **Second** and t3 prints **Third**. The code for the class is as follows:

```java
public class OrderedPrinting {

    public void printFirst() {
       System.out.print("First"); 
    }
 
    public void printSecond() {
       System.out.print("Second");
    }

    public void printThird() {
       System.out.print("Third"); 
    }

}
```

Thread t1 calls printFirst(), thread t2 calls printSecond(), and thread t3 calls printThird(). The threads can run in any order. You have to synchronize the threads so that the functions **printFirst()**, **printSecond()** and **printThird()** are executed in order.

The workflow of the program is shown below:


# Solution

We present two solutions for this problem; one using the basic `wait()` & `notifyAll()` functions and the other using **CountDownLatch**.

**Solution 1**
In this solution, we have a class `OrderedPrinting` that consists of a private variable; `count`. The class consists of 3 functions `printFirst()`,`printSecond()` and `printThird()`. The structure of the class is as follows:

```java
class OrderedPrinting {
    int count;

    public OrderedPrinting() {
        count = 1;
    }
    
    public void printFirst() {
    }
 
    public void printSecond() {
    }

    public void printThird() {
    }
}
```
In the constructor, `count` is initialized with 1. Next we will explain the `printFirst()` function below:

```java
public void printFirst() throws InterruptedException {

    synchronized(this) {
        System.out.println("First");
        count++; //for printing Second, increment count
        this.notifyAll();
    }
}
```

In `printFirst()`, "First" is printed. We do not need to check the value of `count` here. After printing, `count` is incremented for the next word to be printed. Any waiting threads are then notified via `notifyAll()`, signalling them to proceed.

```java
public void printSecond() throws InterruptedException {
        
    synchronized(this) {
        while(count != 2) {
            this.wait();
        }
        System.out.println("Second");
        count++;
        this.notifyAll();
    }
}
````
In the second method, the value of `count` is checked. If it is not equal to 2, the calling thread goes into wait. When the value of `count` reaches 2, the while loop is broken and "Second" is printed. The value of `count` is incremented for the next number to be printed and `notifyAll()` is called.

```java
public void printThird() throws InterruptedException {

    synchronized(this) {
        while(count != 3) {
            this.wait();
        }
        System.out.println("Third");
    }
}
```

The third method checks works in the same way as the second. The only difference being the check for `count` to be equal to 3. If it is, then "Third" is printed otherwise the calling thread waits.


To run our proposed solution, we will create another class to achieve multi-threading. When we extend `Thread` class, each of our thread creates a unique object and associates with the parent class. This class has two variables: one is the object of `OrderedPrinting` and the other is a string variable `method`. The string parameter checks the method to be invoked from `OrderedPrinting`.

```java
class OrderedPrintingThread extends Thread {
    private OrderedPrinting obj;
    private String method; 

    public OrderedPrintingThread(OrderedPrinting obj, String method) {
        this.method = method;
        this.obj = obj;
    }

    public void run() {
        //for printing "First"
        if ("first".equals(method)) {
            try {
                obj.printFirst();
            }
            catch(InterruptedException e) { 
                
            }
        } 
        //for printing "Second"
        else if ("second".equals(method)) {
            try {
                obj.printSecond();
            }
            catch(InterruptedException e) { 
                
            }
        }
        //for printing "Third" 
        else if ("third".equals(method)) {
            try {
                obj.printThird();
            }
            catch(InterruptedException e) { 
                
            }
        }
    }
}
```
We will be creating 3 threads in the `Main` class for testing each solution. Each thread will be passed the same object of `OrderedPrinting`. **t1** will call `printFirst()`, **t2** will call `printSecond()` and **t3** will call `printThird()`. The output shows printing done in the proper order i.e first, second and third irrespective of the calling order of threads.


This problem is about imposing an order on thread execution.

The Basics

Multithreading in Java

Java's Memory Model

Interview Practice Problems

Bonus Questions

Beyond the Interview

Java Concurrency Reference

Revision & Quizzes

Ordered Printing

Problem Statement

Solution