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 we have a machine that creates molecules by combining atoms. We are creating water molecules by joining one Oxygen and two Hydrogen atoms. The atoms are represented by threads. The machine will wait for the required atoms (threads), then group one Oxygen and two Hydrogen threads to simulate the creation of a molecule. The molecule then exists the machine. You have to ensure that one molecule is completed before moving onto the next molecule. If more than the required number of threads arrive, they will have to wait. The figure below explains the working of our machine:

Two Hydrogen threads are admitted in the machine as they arrive but when the third thread arrives in step 3, it is made to wait. When an Oxygen thread arrives in step 4, it is allowed to enter the machine. A water molecule is formed in step 5 which exists the machine in step 6. That is when the waiting Hydrogen thread is notified and the process of creating more molecules continues. The threads can arrive in any order which means that HHO, OHH and HOH are all valid outputs.

The code for the class is as follows:

```java
class H2OMachine {

    public H2OMachine() {
        
    }

    public void HydrogenAtom() {
        
    }

    public void OxygenAtom() {        
        
    }
}
```

The input to the machine can be in any order. Your program should enforce a 2:1 ratio for Hydrogen and Oxygen threads, and stop more than the required number of threads from entering the machine.

# Solution

Our molecule making machine is represented by the class `H2OMachine`, which contains two main methods; `HydrogenAtom()` and `OxygenAtom()`.

The problem is solved by using basic utility functions like `notify()` and `wait()`. The class consits of 3 private members:
`sync` for synchronization, `molecule` which is a string array with a capacity of 3 elements (atoms) and `count` to store the current index of the molecule array.

```java
class H2OMachine {
    Object sync;
    String[] molecule;
    int count; 

    public H2OMachine() { 
    }

    public void HydrogenAtom() {
    }

    public void OxygenAtom() {        
    }
}
```
The constructor initializes the `molecule` array with a capacity of 3 atoms and the integer `count` is initialized with 0.

```java
public H2OMachine() {
    molecule = new String[3];
    count = 0;
    sync = new Object();
}
```
For synchronization purpose, the entire logic of `HydrogenAtom()` is wrapped in `sync`.  First of all, we check the frequency of Hydrogen atom in the `molecule` array by using `frequency()` function found in the **Collections** library of Java. The function deals the array `molecule` as an ArrayList and checks the count of Hydrogen atoms in it. If the array has reached its capacity of 2 Hydrogen atoms, then the thread should wait for space in a new molecule. If the frequency of Hydrogen is less than 2 it means space is available in the current molecule. Hence, H is placed in the array and `count` is incremented. So far, the code of `HydrogenAtom()` is as follows:

```java
public void HydrogenAtom() {
   synchronized (sync) {
          
      // if 2 hydrogen atoms already exist
      while (Collections.frequency(Arrays.asList(molecule), "H") == 2) { 
          sync.wait();
      }

      molecule[count] = "H";
      count++;
   }
}
```
In case `molecule` is full and `count` is 3, then print the `molecule` and exit the machine. The array `molecule` is reset (initialized with null) and `count` goes back to 0 for a new molecule to be built. At the end of the method, the waiting threads (atoms) are notified using `notifyAll()`. The complete code for `HydrogenAtom()`is given below:

```java
public void HydrogenAtom() {
    synchronized (sync) {

        // if 2 hydrogen atoms already exist
        while (Collections.frequency(Arrays.asList(molecule),"H") == 2) { 
            sync.wait();
        }
        molecule[count] = "H";
        count++;

        // if molecule is full, then exit.
        if(count == 3) {
            for (String element: molecule) {
                System.out.print(element);
            }
            Arrays.fill(molecule,null);
            count = 0;
        }
        sync.notifyAll();
    }
}
```
The second method `OxygenAtom()` is the same as `HydrogenAtom()` with the only difference of the atom frequency check in the array `molecule`. If it contains one Oxygen atom, then the calling thread goes into `wait()`. If the count of Oxygen atom is not equal to 1  in the `molecule`, then an Oxygen atom "O" is placed in the next available space. The complete code of `OxygenAtom()` is shown below:

```java
public void oxygen() {
    synchronized (sync) {

        // if 1 oxygen atom already exists
        while (Collections.frequency(Arrays.asList(molecule),"O") == 1) {
            sync.wait();
        }

        molecule[count] = "O";
        count++;

        // if molecule is full, then exit.
        if(count == 3) {
            for (String element: molecule) {
                System.out.print(element);
            }
            Arrays.fill(molecule,null);
            count = 0;
        }
        sync.notifyAll();
    }
}
```
<p>The complete code for the solution is as follows:</p>

```java
class H2OMachine {

    Object sync;
    String[] molecule;
    int count; 

    public H2OMachine() {
        molecule = new String[3];
        count = 0;
        sync = new Object();
    }

    public void HydrogenAtom() {
        synchronized (sync) {

            // if 2 hydrogen atoms already exist
            while (Collections.frequency(Arrays.asList(molecule),"H") == 2) { 
                sync.wait();
            }

            molecule[count] = "H";
            count++;

            // if molecule is complete, then exit.
            if(count == 3) {
                for (String element: molecule) {
                    System.out.print(element);
                }
                Arrays.fill(molecule,null);
                count = 0;
            }
            sync.notifyAll();
        }
    }
   
    public void OxygenAtom() throws InterruptedException {
        synchronized (sync) {

            // if 1 oxygen atom already exists
            while (Collections.frequency(Arrays.asList(molecule),"O") == 1) {
                sync.wait();
            }

            molecule[count] = "O";
            count++;

            // if molecule is complete, then exit.
            if(count == 3) {
                for (String element: molecule) {
                    System.out.print(element);
                }
                Arrays.fill(molecule,null);
                count = 0;
            }
            sync.notifyAll();
        }
    }
}
```

We will be creating another class `H2OMachineThread` for multi-threading purpose. It takes an object of `H2OMachine` and calls the relevant method from the string passed to it.

```java
class H2OMachineThread extends Thread {

    H2OMachine molecule;
    String atom;
    
    public H2OMachineThread(H2OMachine molecule, String atom){
        this.molecule = molecule;
        this.atom = atom;
    }
    
    public void run() {
        if ("H".equals(atom)) {
            try {
                molecule.HydrogenAtom();
            }
            catch (Exception e) {
            }
        }
        else if ("O".equals(atom)) {
            try {
                molecule.OxygenAtom();
            }
            catch (Exception e) {
            }
        }
    }
}
```
We will now be creating 4 threads in order to test our proposed solution. Same object of `H2OMachine` is passed to the 4 threads: **t1**, **t2**, **t3** and **t4**. **t1** and **t3** act as Hydrogen atoms trying to enter the machine where as **t2** and **t4** act as Oxygen atoms. It can be seen from the output that only 1 molecule of H2O exits the machine while the extra Oxygen atom is not utilized.


This problem simulated the creation of water molecule by grouping three threads representing Hydrogen and Oxygen atoms.

The Basics

Multithreading in Java

Java's Memory Model

Interview Practice Problems

Bonus Questions

Beyond the Interview

Java Concurrency Reference

Revision & Quizzes

Build a Molecule

Problem Statement