The Art of Synchronization: Coordinating Resources in Java#

Creating Threads#

In Java, you typically create a thread by either:

• Extending the Thread class and overriding run().
• Implementing the Runnable interface and passing an instance to a Thread.
• Using the newer concurrency framework (ExecutorService) which manages threads behind the scenes.

Example of creating and starting threads:

1
public class SimpleThreadExample {
2
    public static void main(String[] args) {
3
        // Using a Thread subclass
4
        Thread threadA = new Thread() {
5
            @Override
6
            public void run() {
7
                System.out.println("Thread A is running.");
8
            }
9
        };
10

11
        // Using Runnable
12
        Runnable runnableB = () -> System.out.println("Thread B is running.");
13
        Thread threadB = new Thread(runnableB);
14

15
        threadA.start();
16
        threadB.start();
17
    }
18
}

Thread Lifecycle#

Each Java thread goes through these primary states:

1. New: The thread is created but not started (new Thread(runnable)).
2. Runnable: The thread is eligible to run, though not necessarily running on the CPU at every moment.
3. Running: The thread is actively executing instructions on the CPU.
4. Blocked/Waiting: The thread is waiting for a resource or a notification to proceed.
5. Terminated: The thread has finished execution.

Synchronization directly impacts states when multiple threads vie for resources. Some might be blocked, waiting for locks or other signals.

Synchronized Methods#

When you mark a method as synchronized, you effectively say, “Only one thread can enter this method on a given instance at a time.” For instance:

1
public class SynchronizedCounter {
2
    private int count = 0;
3

4
    public synchronized void increment() {
5
        count++;
6
    }
7

8
    public synchronized int getCount() {
9
        return count;
10
    }
11
}

• increment() and getCount() are synchronized on the this object.
• Locked code ensures that if Thread A is in increment(), Thread B cannot enter either increment() or getCount() on the same object.

Synchronized Blocks#

If you don’t want to synchronize the entire method, you can synchronize only a portion with a synchronized block:

1
public class PartialSyncCounter {
2
    private int count = 0;
3
    private final Object lock = new Object();
4

5
    public void increment() {
6
        synchronized (lock) {
7
            count++;
8
        }
9
    }
10

11
    public int getCount() {
12
        synchronized (lock) {
13
            return count;
14
        }
15
    }
16
}

• This provides more fine-grained control.
• The lock object (this or a custom lock) ensures only one thread can enter that block at a time.

Intrinsic Locks#

Every Java object has an intrinsic lock (or monitor lock). When you use:

1
synchronized (someObject) {
2
   // ...
3
}

you lock on someObject’s intrinsic lock. Another thread trying to synchronize on that same object must wait until the lock is released.

Visibility Guarantees#

Besides ensuring that no two threads execute a synchronized block simultaneously, Java’s memory model guarantees that changes within a synchronized block are visible to other threads that enter a synchronized block guarded by the same lock. This is crucial for consistency across threads.

ReentrantLock Basics#

ReentrantLock extends the concept of locks to:

• Provide a way to lock and unlock explicitly.
• Offer more control over the lock acquisition process (e.g., tryLock with timeouts).
• Permit more sophisticated handling of concurrency, such as fairness policies.

Example:

1
import java.util.concurrent.locks.Lock;
2
import java.util.concurrent.locks.ReentrantLock;
3

4
public class LockCounter {
5
    private int count = 0;
6
    private final Lock lock = new ReentrantLock();
7

8
    public void increment() {
9
        lock.lock();
10
        try {
11
            count++;
12
        } finally {
13
            lock.unlock();
14
        }
15
    }
16

17
    public int getCount() {
18
        lock.lock();
19
        try {
20
            return count;
21
        } finally {
22
            lock.unlock();
23
        }
24
    }
25
}

• We use lock.lock() at the start of the critical section and lock.unlock() in the finally block to ensure unlock occurs even if an exception is thrown.
• This pattern ensures resource safety and proper lock release.

Reentrant Behavior#

“Reentrant” means a thread that already owns the lock can reacquire it without deadlocking itself. For example, if a locked method calls another method that also locks the same ReentrantLock, the same thread can continue.

Fair vs. Non-Fair Locks#

ReentrantLock provides fairness options to control how threads acquire locks:

• Non-fair (default): Threads requesting a lock can “jump the queue” if it becomes available, maximizing throughput but potentially starving some threads.
• Fair: Threads acquire locks in a first-come, first-served manner.

You can construct a fair lock like so:

1
Lock fairLock = new ReentrantLock(true);

However, fair locks can reduce performance under heavy contention.

Basic Steps#

1. A thread (Thread A) acquires the lock (synchronized block) on an object and checks a condition.
2. If the condition is not met, it calls object.wait(). This releases the lock and places Thread A in the wait set, awaiting notification.
3. Another thread (Thread B) acquires the same lock and calls object.notify() or object.notifyAll().
4. When notify() is called, one waiting thread is awakened; with notifyAll(), all waiting threads are awakened. They proceed to re-acquire the lock before resuming.

Classic Producer-Consumer Example#

Consider a producer-consumer scenario using a shared queue:

1
public class ProducerConsumer {
2
    private static final int MAX_CAPACITY = 5;
3
    private final List<Integer> queue = new ArrayList<>();
4

5
    public void produce(int value) throws InterruptedException {
6
        synchronized (queue) {
7
            while (queue.size() == MAX_CAPACITY) {
8
                queue.wait(); // Wait if the queue is full
9
            }
10
            queue.add(value);
11
            System.out.println("Produced: " + value);
12
            queue.notifyAll(); // Notify consumers
13
        }
14
    }
15

16
    public int consume() throws InterruptedException {
17
        synchronized (queue) {
18
            while (queue.isEmpty()) {
19
                queue.wait(); // Wait if the queue is empty
20
            }
21
            int value = queue.remove(0);
22
            System.out.println("Consumed: " + value);
23
            queue.notifyAll(); // Notify producers
24
            return value;
25
        }
26
    }
27
}

Key notes:

• We use while (not if) in loops around wait(). This prevents spurious wakeups and re-checks conditions.
• notifyAll() is typically safer in these scenarios to ensure all waiting threads can re-check their conditions.

Choosing Between wait/notify and Other Constructs#

While wait(), notify(), and notifyAll() are extremely flexible, they can be tricky to use correctly. You must be careful with acquiring and releasing the lock. In many cases, higher-level concurrency utilities (like BlockingQueue, Semaphore, or other classes in java.util.concurrent) can simplify your code, reduce mistakes, and improve maintainability.

Thread-Safe Data Structures#

• Collections.synchronizedXxx: Wrappers around standard collections. E.g., Collections.synchronizedList(new ArrayList<>()).
• Concurrent Collections:
  • ConcurrentHashMap: Allows concurrent reads and updates without locking the entire map.
  • CopyOnWriteArrayList, CopyOnWriteArraySet: Great for scenarios with frequent reads and infrequent writes.
  • ConcurrentLinkedQueue, LinkedBlockingQueue, and other concurrent queues for producer-consumer patterns.

Example using ConcurrentHashMap:

1
import java.util.concurrent.ConcurrentHashMap;
2

3
public class ConcurrentMapExample {
4
    private final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
5

6
    public void incrementKey(String key) {
7
        map.merge(key, 1, Integer::sum);
8
    }
9

10
    public int getValue(String key) {
11
        return map.getOrDefault(key, 0);
12
    }
13
}

ConcurrentHashMap provides concurrency-friendly operations without the developer needing to handle synchronization explicitly in many cases.

Atomic Classes#

For simple operations on shared variables, the Java java.util.concurrent.atomic package provides classes like:

• AtomicInteger
• AtomicLong
• AtomicReference

Each class offers thread-safe atomic operations (like incrementAndGet(), compareAndSet()). Example:

1
import java.util.concurrent.atomic.AtomicInteger;
2

3
public class AtomicCounter {
4
    private AtomicInteger count = new AtomicInteger(0);
5

6
    public int increment() {
7
        return count.incrementAndGet();
8
    }
9

10
    public int getValue() {
11
        return count.get();
12
    }
13
}

These classes eliminate the need for your own synchronization when performing discrete atomic updates.

ExecutorService#

ExecutorService provides a higher-level abstraction to manage worker threads:

1
import java.util.concurrent.ExecutorService;
2
import java.util.concurrent.Executors;
3

4
public class ExecutorExample {
5
    public static void main(String[] args) {
6
        ExecutorService executor = Executors.newFixedThreadPool(4);
7

8
        for (int i = 0; i < 10; i++) {
9
            final int taskNumber = i;
10
            executor.submit(() -> {
11
                System.out.println("Task " + taskNumber + " is running on "
12
                                   + Thread.currentThread().getName());
13
            });
14
        }
15

16
        executor.shutdown();
17
    }
18
}

• You define how many threads you want in a pool (4 in the example).
• You submit tasks (Runnable or Callable) to the executor.
• Internally, the executor chooses an available thread from the pool to run the task, or queues the task if all threads are busy.
• executor.shutdown() initiates a graceful shutdown, allowing ongoing tasks to finish.

Schedulers, ScheduledExecutorService#

Need a task to run periodically? Use ScheduledExecutorService:

1
import java.util.concurrent.Executors;
2
import java.util.concurrent.ScheduledExecutorService;
3
import java.util.concurrent.TimeUnit;
4

5
public class ScheduledTaskExample {
6
    public static void main(String[] args) {
7
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
8
        // Run a task after a delay of 5 seconds
9
        scheduler.schedule(() -> System.out.println("Delayed task"), 5, TimeUnit.SECONDS);
10

11
        // Run a task at a fixed rate of 2 seconds
12
        scheduler.scheduleAtFixedRate(() -> System.out.println("Repeated task"),
13
                                      2,
14
                                      2,
15
                                      TimeUnit.SECONDS);
16
    }
17
}

Future and Callable#

submit() can be used to run tasks that return a value. The Future object can retrieve the result, check if the task is done, or cancel it:

1
import java.util.concurrent.*;
2

3
public class FutureExample {
4
    public static void main(String[] args) {
5
        ExecutorService executor = Executors.newSingleThreadExecutor();
6

7
        Callable<Integer> callableTask = () -> {
8
            TimeUnit.SECONDS.sleep(2);
9
            return 42;
10
        };
11

12
        Future<Integer> futureResult = executor.submit(callableTask);
13

14
        try {
15
            // get() will block until the task completes
16
            Integer result = futureResult.get();
17
            System.out.println("Computed value: " + result);
18
        } catch (InterruptedException | ExecutionException e) {
19
            e.printStackTrace();
20
        } finally {
21
            executor.shutdown();
22
        }
23
    }
24
}

Semaphores#

A Semaphore manages a set of permits that allow multiple threads to access resources up to a limit. For example, limiting concurrency to a specified number:

1
import java.util.concurrent.Semaphore;
2

3
public class ConnectionLimiter {
4
    private final Semaphore semaphore;
5

6
    public ConnectionLimiter(int maxConnections) {
7
        semaphore = new Semaphore(maxConnections);
8
    }
9

10
    public void acquireConnection() throws InterruptedException {
11
        semaphore.acquire();
12
    }
13

14
    public void releaseConnection() {
15
        semaphore.release();
16
    }
17
}

• Only a specified number of threads (e.g., maxConnections) can acquire the semaphore at once.
• Other threads must wait.

CountDownLatch#

A CountDownLatch makes one or more threads wait until a set of operations done by other threads completes. Example: wait for 5 tasks to finish:

1
import java.util.concurrent.CountDownLatch;
2

3
public class LatchExample {
4
    public static void main(String[] args) throws InterruptedException {
5
        CountDownLatch latch = new CountDownLatch(5);
6

7
        // Start five tasks in separate threads
8
        for (int i = 0; i < 5; i++) {
9
            new Thread(() -> {
10
                // Perform some work
11
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
12
                latch.countDown();
13
                System.out.println(Thread.currentThread().getName() + " finished.");
14
            }).start();
15
        }
16

17
        latch.await(); // Wait until all five tasks have called countDown()
18
        System.out.println("All tasks completed.");
19
    }
20
}

CyclicBarrier#

Similar to CountDownLatch but reusable. A CyclicBarrier makes a group of threads wait at a common barrier point until all have arrived, then the barrier is reset:

1
import java.util.concurrent.CyclicBarrier;
2

3
public class BarrierExample {
4
    public static void main(String[] args) {
5
        int parties = 3;
6
        CyclicBarrier barrier = new CyclicBarrier(parties, () -> {
7
            System.out.println("All parties arrived at barrier. Let's continue...");
8
        });
9

10
        for (int i = 0; i < parties; i++) {
11
            new Thread(() -> {
12
                try {
13
                    System.out.println(Thread.currentThread().getName() + " doing work...");
14
                    Thread.sleep((long) (Math.random() * 2000));
15
                    barrier.await(); // Wait for all threads
16
                } catch (Exception e) {
17
                    e.printStackTrace();
18
                }
19
            }).start();
20
        }
21
    }
22
}

Phaser#

A Phaser is a more flexible synchronization barrier than CyclicBarrier. It can handle dynamic registration of parties and synchronization across multiple phases.

Other Best Practices#

1. Immutable objects: If data never changes, you don’t need synchronization. Immutability is a simpler model of concurrency.
2. Encapsulation: Keep lock objects private and do not leak them outside your class.
3. Use concurrency-friendly libraries: Avoid reinventing concurrency constructs. Leverage the standard library’s concurrency tools.
4. Prefer concurrency frameworks over low-level threads: ExecutorService, parallel streams, and other frameworks can greatly simplify concurrency.