20.4. Tools for Thread Safety in Java

Use synchronized to enforce mutual exclusion and visibility.

public synchronized void increment() {
    count++;
}

In Java, synchronized blocks and methods help ensure that only one thread can execute them at a time. This is crucial when multiple threads may attempt to access the same variable concurrently. For example, if two threads try to increment a shared variable, without synchronization, they might both read the same initial value and override each other's updates. By marking a method as synchronized, we ensure that once a thread enters that method, no other thread can enter any method marked as synchronized until the first thread exits. This mechanism prevents race conditions and ensures that the shared variable maintains a consistent state.

Think of a single-lane bridge where two cars cannot pass at the same time. If one car is on the bridge, the other car must wait until the first one leaves before it can enter. Similarly, synchronized methods act as that bridge, allowing only one thread to access the critical section of code while others must wait their turn.

Use volatile when:

• Only one thread updates, others read.
• No compound or conditional updates are involved.

volatile boolean running = true;

The volatile keyword in Java is used to indicate that a variable's value may be changed by different threads. Declaring a variable as volatile provides a guarantee that any thread reading the variable will see the most recent write by any other thread. This is particularly useful for flags checked by multiple threads. However, it should be used carefully; if more than one thread writes to a variable or if there are compound operations (like incrementing), volatile does not provide the needed atomicity.

Imagine a shared whiteboard where one person writes a message. If it’s marked as visible (like declaring a variable as volatile), everyone else can read the latest message without delay. However, if multiple people can write on that board simultaneously, the messages might overlap or conflict, just like how volatile doesn’t protect against race conditions.

Atomic classes (like AtomicInteger, AtomicBoolean) allow lock-free thread-safe operations.

AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();

Atomic variables in Java provide a way to perform operations without locking, which can improve performance in multi-threaded environments. For instance, an AtomicInteger allows you to increment a number safely across multiple threads without needing synchronization. When you call methods like incrementAndGet(), the operation is guaranteed to be atomic, meaning it will complete without interference from other threads. This efficiency can be crucial when dealing with high-performance applications that require thread-safe increments.

Consider a bank teller who keeps a record of total deposits. If customers are depositing money simultaneously, instead of locking the teller's desk and making everyone wait, the bank uses a special system that instantly updates the total with each transaction. Each deposit is counted accurately and immediately, representing how atomic operations work in a multi-threaded context.

Use ReentrantLock, ReadWriteLock, or StampedLock for more control.

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // critical section
} finally {
    lock.unlock();
}

Locks provide a more flexible mechanism for controlling access to resources in concurrent programming than synchronized blocks. For example, a ReentrantLock can be locked and unlocked explicitly, allowing for more complex locking strategies. This is useful when you need to attempt to acquire a lock without getting blocked indefinitely or when you want to conduct some logic before deciding to lock. The try-finally construct ensures that the lock is always released, preventing potential deadlocks.

Imagine a restaurant with a shared kitchen. Members of the staff need to use the kitchen at different times. Instead of only one person allowed in at any time, they can use a sign-up sheet (locks) to reserve their time in the kitchen, allowing them to leave the kitchen as soon as they’re done while ensuring that others can cook without waiting for long periods. Just as with using ReentrantLock, this system can improve efficiency and manage access better.

--