If you want to ensure that the three threads T1, T2, and T3 run in sequential order in Java, one approach is to use a Semaphore to control the execution of the threads. Here’s an example:
Semaphore sem1 = new Semaphore(1); // Initialize with 1 permit
Semaphore sem2 = new Semaphore(0); // Initialize with 0 permits
Semaphore sem3 = new Semaphore(0); // Initialize with 0 permits
Thread t1 = new Thread(() -> {
try {
sem1.acquire(); // Wait for semaphore 1
// Code for thread T1
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
sem2.release(); // Release semaphore 2
}
});
Thread t2 = new Thread(() -> {
try {
sem2.acquire(); // Wait for semaphore 2
// Code for thread T2
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
sem3.release(); // Release semaphore 3
}
});
Thread t3 = new Thread(() -> {
try {
sem3.acquire(); // Wait for semaphore 3
// Code for thread T3
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t1.start();
t2.start();
t3.start();
In this example, we create three Semaphore objects sem1, sem2, and sem3. We initialize sem1 with one permit, sem2 and sem3 with zero permits. The Semaphore with one permit (sem1 in this case) is used to start the first thread (t1 in this case). The Semaphore with zero permits (sem2 in this case) is used to ensure that thread t2 runs after thread t1. Similarly, the Semaphore with zero permits (sem3 in this case) is used to ensure that thread t3 runs after thread t2.
In each thread, we first call the acquire() method on the corresponding Semaphore object to wait for the permit. Once the permit is available, we execute the code for that thread. Finally, we call the release() method on the next Semaphore object to release the permit and allow the next thread to execute.
By using this approach, we can ensure that the three threads T1, T2, and T3 run in sequential order in Java.