Java Synchronization Best Practices

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

Introduction

Synchronization in Java is a mechanism to control access to shared resources by multiple threads. Proper synchronization ensures that only one thread can access a resource at a time, preventing thread interference and memory consistency errors. However, improper synchronization can lead to performance issues, deadlocks, and other concurrency problems. This guide covers best practices for synchronization in Java.

Key Points:

• Thread Safety: Ensuring safe access to shared resources.
• Performance: Minimizing synchronization overhead.
• Avoiding Deadlocks: Preventing situations where threads block each other indefinitely.

Table of Contents

1. Use the synchronized Keyword Appropriately
2. Minimize the Scope of Synchronization
3. Prefer ReentrantLock over synchronized for Advanced Use Cases
4. Use volatile for Simple Flag Synchronization
5. Avoid Nested Locks
6. Use Concurrent Collections
7. Use Read-Write Locks for Improved Concurrency
8. Ensure Proper Exception Handling in Synchronized Blocks
9. Avoid Using Thread.sleep() for Synchronization
10. Use Atomic Variables for Single-Variable Synchronization
11. Prefer Higher-Level Synchronization Utilities
12. Conclusion

1. Use the synchronized Keyword Appropriately

The synchronized keyword can be used to lock methods or blocks of code. Use it to protect critical sections of code that access shared resources.

Example:

public class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

2. Minimize the Scope of Synchronization

Keep the scope of synchronized blocks as small as possible to reduce contention and improve performance.

Example:

public class Counter {
    private int count = 0;

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

    public int getCount() {
        synchronized (this) {
            return count;
        }
    }
}

3. Prefer ReentrantLock over synchronized for Advanced Use Cases

For more advanced synchronization needs, such as try-lock or timed-lock, use ReentrantLock from the java.util.concurrent.locks package.

Example:

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

4. Use volatile for Simple Flag Synchronization

For simple flags that are accessed by multiple threads, use the volatile keyword to ensure visibility of changes across threads.

Example:

public class Flag {
    private volatile boolean flag = false;

    public void setFlag(boolean value) {
        flag = value;
    }

    public boolean isFlag() {
        return flag;
    }
}

5. Avoid Nested Locks

Avoid acquiring multiple locks at once to prevent deadlocks. If nested locks are necessary, ensure that all threads acquire the locks in the same order.

Example:

public class DeadlockAvoidance {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            synchronized (lock2) {
                // Critical section
            }
        }
    }

    public void method2() {
        synchronized (lock1) {
            synchronized (lock2) {
                // Critical section
            }
        }
    }
}

6. Use Concurrent Collections

Prefer concurrent collections like ConcurrentHashMap, CopyOnWriteArrayList, and BlockingQueue for thread-safe operations without explicit synchronization.

Example:

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentCollectionExample {
    private final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    public void putValue(String key, Integer value) {
        map.put(key, value);
    }

    public Integer getValue(String key) {
        return map.get(key);
    }
}

7. Use Read-Write Locks for Improved Concurrency

For scenarios with multiple readers and few writers, use ReadWriteLock to allow concurrent reads while still providing exclusive access for writes.

Example:

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private int value;

    public void writeValue(int newValue) {
        lock.writeLock().lock();
        try {
            value = newValue;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int readValue() {
        lock.readLock().lock();
        try {
            return value;
        } finally {
            lock.readLock().unlock();
        }
    }
}

8. Ensure Proper Exception Handling in Synchronized Blocks

Always ensure that locks are released in the finally block to prevent potential deadlocks in case of exceptions.

Example:

public class ProperExceptionHandling {
    private final ReentrantLock lock = new ReentrantLock();

    public void performTask() {
        lock.lock();
        try {
            // Critical section
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

9. Avoid Using Thread.sleep() for Synchronization

Do not use Thread.sleep() for synchronization purposes, as it can lead to unpredictable behavior and poor performance. Use proper synchronization techniques instead.

Example:

public class AvoidThreadSleep {
    private final Object lock = new Object();

    public void performTask() {
        synchronized (lock) {
            try {
                // Simulate work
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

10. Use Atomic Variables for Single-Variable Synchronization

For single-variable synchronization, use atomic variables like AtomicInteger, AtomicBoolean, etc., from the java.util.concurrent.atomic package.

Example:

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicVariableExample {
    private final AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

11. Prefer Higher-Level Synchronization Utilities

Use higher-level synchronization utilities like Semaphore, CountDownLatch, and CyclicBarrier from the java.util.concurrent package for complex synchronization scenarios.

Example using CountDownLatch:

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(3);

    public void performTask() throws InterruptedException {
        // Simulate task
        latch.countDown();
    }

    public void awaitCompletion() throws InterruptedException {
        latch.await();
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatchExample example = new CountDownLatchExample();
        Thread t1 = new Thread(() -> {
            try {
                example.performTask();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                example.performTask();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t3 = new Thread(() -> {
            try {
                example.performTask();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        t2.start();
        t3.start();

        example.awaitCompletion();
        System.out.println("All tasks completed.");
    }
}

12. Conclusion

Synchronization in Java is essential for ensuring thread safety in concurrent applications. However, improper use of synchronization can lead to performance issues and deadlocks. By following these best practices, you can write efficient, thread-safe, and maintainable Java code.

Summary of Best Practices:

• Use the synchronized keyword appropriately.
• Minimize the scope of synchronization.
• Prefer ReentrantLock over synchronized for advanced use cases.
• Use volatile for simple flag synchronization.
• Avoid nested locks.
• Use concurrent collections.
• Use read-write locks for improved concurrency.
• Ensure proper exception handling in synchronized blocks.
• Avoid using Thread.sleep() for synchronization.
• Use atomic variables for single-variable synchronization.
• Prefer higher-level synchronization utilities.

By adhering to these best practices, you can enhance the reliability and performance of your Java applications in a multi-threaded environment.