Effective Java Thread Management: A Fun Washroom Example
My previous article explored the exciting world of Virtual threads in Java 21. Virtual threads are a powerful feature that simplifies concurrent programming, making it more efficient and less error-prone. However, before diving deep into advanced topics like Virtual threads, it’s essential to understand the basics of threading and how to manage shared resources effectively.
One common challenge when working with threads is ensuring that multiple threads can access shared resources without conflicts. This is where synchronization comes into play. To illustrate these fundamental concepts in a fun and relatable way, we’ll use a simple yet amusing example involving a shared washroom.
In this article, we’ll break down the basics of threading in Java using the washroom example. You’ll learn how to synchronize access to a shared resource, manage thread coordination, and avoid common pitfalls. Let’s dive in!
Understanding Threads with the Washroom Example
To understand how threading and synchronization work in Java, let’s consider a simple scenario: a shared washroom. In this scenario, we have three types of users:
- People with Quick Needs: These are the users who need to use the washroom for a short period.
- People with Longer Needs: These users take a bit more time in the washroom.
- The Cleaner: This user cleans the washroom, but only when it’s dirty.
Here are the rules for our washroom:
- Only one person can use the washroom at a time. Whether it’s for quick needs or longer needs, the washroom can only accommodate one user at a time.
- After each use, the washroom is marked as dirty.
- The cleaner checks if the washroom is dirty. If it is, the cleaner will clean it. The cleaner can only clean the washroom when no one else is using it.
This example is a perfect analogy for understanding how to manage access to a shared resource (the washroom) using threads. We’ll use Java synchronization mechanisms to ensure that only one thread (user) can access the resource at a time and to coordinate the actions of different threads.
Writing the Code and Explanation
We’ll start by defining the Washroom
class and then incrementally add methods to handle quick needs, long needs, and cleaning.
Setting Up the Washroom Class
First, let’s create the basic structure of the Washroom
class:
public class Washroom {
private boolean dirty = false; // Indicates if the washroom is dirty
}
Handling Quick Needs
Next, let’s add a method to handle quick needs in the washroom. This method will:
- Check if the Washroom is Dirty: If the washroom is dirty, the thread will wait until it is cleaned.
- Use the Washroom: Once the washroom is available, the thread will simulate a quick need with a short sleep, mark it as dirty, and then finish.
- Notify Other Threads: After finishing, the thread will notify all waiting threads that the washroom has been used and is now dirty.
// Method for quick needs
public void useWashroomQuick() throws InterruptedException {
String name = Thread.currentThread().getName();
System.out.println(name + " is in line.");
synchronized (this) { // Synchronize on the current instance
while (dirty) {
System.out.println(name + " - washroom is dirty. Waiting to use the washroom (quick need)");
wait();
}
System.out.println(name + " is using the washroom for quick need");
Thread.sleep(5000); // Simulate quick need
dirty = true; // Mark washroom as dirty
System.out.println(name + " finished using the washroom");
notifyAll(); // Notify all waiting threads
}
}
This method uses synchronization to ensure that only one thread can execute the critical section at a time. If the washroom is dirty, the thread waits (wait()
) until it is notified that the washroom has been cleaned. Once the washroom is available, the thread marks it as dirty and simulates using it with Thread.sleep(5000)
. After using the washroom, the thread notifies all waiting threads (notifyAll()
) that the washroom is now dirty.
The synchronized
is used with this
to lock the current instance of the Washroom
object. This means that the lock is associated with the specific instance, ensuring that no other thread can enter any synchronized block of code on the same object at the same time. In this context, this
acts like a mutex or key that only one thread can hold at a time, ensuring exclusive access to the critical section of code.
Handling Long Needs
Now, let’s add a method to handle long needs in the washroom. This method follows a similar pattern to the quick needs method but simulates a longer usage time.
// Method for long needs
public void useWashroomLong() throws InterruptedException {
String name = Thread.currentThread().getName();
System.out.println(name + " is in line.");
synchronized (this) {
while (dirty) {
System.out.println(name + " - washroom is dirty. Waiting to use the washroom (long need)");
wait();
}
System.out.println(name + " is using the washroom for long need");
Thread.sleep(8000); // Simulate long need
dirty = true;
System.out.println(name + " finished using the washroom");
notifyAll();
}
}
Cleaning the Washroom
Finally, let’s add the method to clean the washroom. This method will check if it is dirty. If the washroom is not dirty, the thread will wait until it is used. Once the washroom is dirty, the thread will clean it and mark it as clean. After cleaning, the thread will notify all waiting threads that the washroom is now clean.
// Method for cleaning the washroom
public void cleanWashroom() throws InterruptedException {
String name = Thread.currentThread().getName();
synchronized (this) {
System.out.println(name + " is checking if the washroom needs cleaning.");
if (!dirty) {
System.out.println(name + " - washroom is clean. Leaving the washroom.");
return;
}
System.out.println(name + " is cleaning the washroom");
Thread.sleep(5000); // Simulate cleaning
dirty = false;
System.out.println(name + " finished cleaning the washroom. Leave the washroom.");
notifyAll();
}
}
Creating Task Classes for Washroom Simulation
We will now create specific task classes for each type of washroom task. Creating specific task classes for each type of washroom task is a good design choice. It makes the code more modular, adheres to the Single Responsibility Principle, and ensures clear separation of concerns. This approach improves readability and maintainability.
Defining the WashroomQuickTask
public class WashroomQuickTask implements Runnable {
private final Washroom washroom;
public WashroomQuickTask(Washroom washroom) {
this.washroom = washroom;
}
@Override
public void run() {
try {
washroom.useWashroomQuick();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
Defining the WashroomLongTask
public class WashroomLongTask implements Runnable {
private final Washroom washroom;
public WashroomLongTask(Washroom washroom) {
this.washroom = washroom;
}
@Override
public void run() {
try {
washroom.useWashroomLong();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
Defining the WashroomCleanTask
The cleaner task is placed in a while(true)
loop to ensure it continuously checks and cleans the washroom as long as the program is running. Without the loop, the cleaner would clean the washroom just once and exit, leaving other tasks potentially waiting indefinitely if the washroom gets dirty again. The while(true)
loop keeps the cleaner active and responsive, ensuring that the washroom remains usable for all other tasks.
public class WashroomCleanTask implements Runnable {
private final Washroom washroom;
public WashroomCleanTask(Washroom washroom) {
this.washroom = washroom;
}
@Override
public void run() {
while (true) {
try {
washroom.cleanWashroom();
Thread.sleep(5000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
Running the Scenario
Now, let’s create the threads to simulate people using and cleaning the washroom:
public class WashroomSimulation {
public static void main(String[] args) throws Exception{
Washroom washroom = new Washroom();
Thread person1 = new Thread(new WashroomQuickTask(washroom), "Person 1");
Thread person2 = new Thread(new WashroomLongTask(washroom), "Person 2");
Thread cleaner = new Thread(new WashroomCleanTask(washroom), "Cleaner");
Thread person4 = new Thread(new WashroomQuickTask(washroom), "Person 4");
cleaner.setDaemon(true);
person1.start();
person2.start();
cleaner.start();
person4.start();
}
}
In this simulation, we set the cleaner thread as a daemon thread using cleaner.setDaemon(true)
. This ensures that the cleaner thread runs continuously in the background, performing its cleaning task as long as the program is running. By making it a daemon thread, we allow the JVM to exit when all non-daemon threads have finished, ensuring that the cleaner doesn't prevent the program from shutting down properly. This setup ensures the washroom is always available for use without any hanging threads waiting indefinitely.
Here is an example of the result you might see when running this code:
Cleaner is checking if the washroom needs cleaning.
Person 4 is in line.
Person 2 is in line.
Person 1 is in line.
Cleaner - washroom is clean. Leaving the washroom.
Person 1 is using the washroom for quick need
Person 1 finished using the washroom
Person 2 - washroom is dirty. Waiting to use the washroom (long need)
Person 4 - washroom is dirty. Waiting to use the washroom (quick need)
Cleaner is cleaning the washroom
Cleaner finished cleaning the washroom. Leave the washroom.
Person 2 is using the washroom for long need
Person 2 finished using the washroom
Cleaner is checking if the washroom needs cleaning.
Cleaner is cleaning the washroom
Cleaner finished cleaning the washroom. Leave the washroom.
Person 4 is using the washroom for quick need
Person 4 finished using the washroom
Conclusion
In this article, we’ve explored the basics of threading and synchronization in Java using a washroom example. We created specific task classes for quick needs, long needs, and cleaning, ensuring a modular and maintainable design. By using the synchronized
keyword, we ensured that only one thread could access the critical section at a time, effectively managing our shared resource – the washroom. The synchronized
block, along with the this
reference, acted like a mutex, providing exclusive access to the washroom for one thread at a time.
We also made the cleaner task run continuously in a daemon thread to keep the washroom clean as long as the program runs, ensuring that the washroom is always available for use. This setup avoided potential issues with threads waiting indefinitely.
I encourage you to experiment with different approaches and scenarios to deepen your understanding of threading and synchronization in Java. Try adding more tasks, handling different types of resources, or exploring other synchronization mechanisms.
Happy coding!
Want to come work with us at Just Eat Takeaway.com? Check out our open roles.