Background
Let us say you have two threads - one thread prints even numbers and other one prints odd numbers. You need to design this in such a way that all the numbers are printed in the natural order i.e 1,2,3,4 etc.
This is more of a synchronization questions rather than a data structure question. You need to understand how threads, synchronization works in order to be able to solve this question.
How to print odd and even numbers in order with two threads
We can do this two ways -
- Using Sempahores
- Using wait and notify
Let us see how we can do this using semaphores -
public static void withSemaphores() throws InterruptedException, ExecutionException {
Semaphore oddLock = new Semaphore(1);
Semaphore evenLock = new Semaphore(0);
Runnable printOdd = () -> {
for (int i = 1; i < 10; i = i + 2) {
try {
oddLock.acquire();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
;
System.out.println(i);
evenLock.release();
}
};
Runnable printEven = () -> {
for (int i = 2; i < 10; i = i + 2) {
try {
evenLock.acquire();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(i);
oddLock.release();
}
};
new Thread(printOdd).start();
new Thread(printEven).start();
}
Before we see how this is actually working you need to understand how semaphores work. They essentially are like permits. You can initialize the semaphore with the initial permits. Let us say semaphore has 2 permits, to begin with. In this case, 2 threads can acquire these permits. The 3rd thread which comes has to wait till one of the 2 permits become available again. Threads that have acquired the permits can release them once they are done. Permits are acquired by acquire() method and released by release() method. To read more about Semaphores you can refer a post I had written earlier -
Also, note I have used Java 8 lambda syntax in the code above. You can read more about lambds -
Now with this understanding let's see how the above logic works.
printOdd runnable is responsible for printing odd numbers whereas printEven prints even number. For loop is designed in such a way and it increments by 2 to continue printing respective numbers. We need to start with 1 which is odd, so old thread starts first. Notice we have 2 semaphores - one for odd and one for even. Odd semaphore has 1 permit whereas even semaphore has 0, to begin with. The odd thread can get the permit from an odd semaphore and print the odd value which is 1. Meanwhile, the even thread will get blocked since no permits are available for even semaphore. Only when an odd thread releases even semaphore permit, even thread will go ahead and print 2. That's how each thread locks each other till numbers are printed in sequence.
You can do the same with the wait and notify. You can see both of the above methods on my GitHub repository on data structures - https://github.com/aniket91/DataStructures/blob/master/src/com/osfg/questions/PrintOddEven.java
