Different ways to make code thread safe in Java

Ensuring thread safety is crucial in multi-threaded Java applications to prevent race conditions and data inconsistencies.

Here are Different ways to make code thread safe in Java

Synchronization using synchronized keyword

• Use the synchronized keyword to synchronize access to critical sections of code or shared resources. This prevents multiple threads from executing the synchronized block concurrently.

   public synchronized void synchronizedMethod() {
       // Thread-safe code
   }

Synchronization using synchronized blocks

• Instead of synchronizing entire methods, use synchronized blocks to synchronize specific sections of code.

   public void synchronizedBlock() {
       synchronized(this) {
           // Thread-safe code
       }
   }

Using java.util.concurrent locks

• Use explicit locks from the java.util.concurrent.locks package, such as ReentrantLock, to control access to shared resources.

   private final Lock lock = new ReentrantLock();

   public void lockExample() {
       lock.lock();
       try {
           // Thread-safe code
       } finally {
           lock.unlock();
       }
   }

Atomic operations using java.util.concurrent.atomic package

• Use atomic classes such as AtomicInteger, AtomicLong, and AtomicReference to perform atomic operations on primitive data types and references.

   private AtomicInteger count = new AtomicInteger(0);

   public void atomicIncrement() {
       count.incrementAndGet(); // Thread-safe operation
   }

Using thread-safe collections

• Use thread-safe implementations of collection classes from the java.util.concurrent package, such as ConcurrentHashMap, CopyOnWriteArrayList, and ConcurrentLinkedQueue.

   Map<String, String> concurrentMap = new ConcurrentHashMap<>();
   List<String> copyOnWriteList = new CopyOnWriteArrayList<>();
   Queue<String> concurrentQueue = new ConcurrentLinkedQueue<>();

Immutable objects

• Design classes to be immutable by making fields final and not providing setters. Immutable objects are inherently thread-safe and can be safely shared among threads.

   public final class ImmutableObject {
       private final int value;

       public ImmutableObject(int value) {
           this.value = value;
       }

       public int getValue() {
           return value;
       }
   }

Thread-local variables

• Use ThreadLocal variables to store thread-specific data. Each thread gets its own copy of the variable, ensuring thread safety without synchronization.

   private static ThreadLocal<Integer> threadLocalValue = ThreadLocal.withInitial(() -> 0);

   public void threadLocalExample() {
       int value = threadLocalValue.get(); // Thread-safe access
       // Modify value
       threadLocalValue.set(value);
   }

Immutable Collections

Use immutable collection classes like those provided by libraries such as Guava or Java 9’s List.of(), Set.of(), Map.of(), etc., to ensure that collections cannot be modified after creation, thus making them thread-safe for reading.

By using above different ways to make code thread safe in Java. By applying these techniques you can effectively make your Java code thread-safe and avoid concurrency issues in multi-threaded environments. Choose the approach that best suits your application’s requirements and design.