What is thread safety in Java? How do you achieve it?

In the realm of concurrent programming, thread safety plays a crucial role in ensuring the stability and correctness of software applications. Java, being a popular programming language for developing concurrent applications, provides various mechanisms to achieve thread safety. In this section, we will explore the concept of thread safety in Java, understand its significance, and delve into techniques to achieve it effectively.

Understanding Thread Safety:

In Java, thread safety indicates to the assets of a given program or class that permits it to be thoroughly used by a couple of threads concurrently with out inflicting unexpected conduct or records corruption. When multiple threads get access to shared resources or mutable state concurrently, numerous issues can arise, which include race conditions, deadlocks, and information inconsistency.

Thread safety ensures that the favoured invariants or properties of an object are preserved, regardless of the interleaved execution of multiple threads. Achieving thread safety requires careful synchronization and proper management of shared resources to ensure predictable and correct behaviour.

Thread Safety Techniques:

1. Immutable Objects:

One of the simplest methods to make certain thread protection is by the usage of immutable objects. Immutable objects are the ones whose state cannot be changed as soon as they may be created. Since immutable objects are read-only, they can be effectively shared among multiple threads without the want for synchronization. Any attempt to modify an immutable item consequence within the creation of a new instance with the updated state.

public final class Demo{
    private final int value;
    public Demo (int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
    public static void main(String[] args) {
        Demo immutableObject = new Demo(42);
        int value = immutableObject.getValue();
        System.out.println("The value of the Main instance is: " + value);
    }
}

Output:

The value of the Main instance is: 42

By making the value field final, we ensure that it cannot be modified after object creation. Therefore, instances of ImmutableClass can be safely shared among multiple threads.

2. Synchronization using the synchronized Keyword:

The synchronized keyword is a fundamental mechanism in Java for achieving thread safety. It allows us to define critical sections of code that can only be executed by one thread at a time, while other threads wait for their turn. This prevents concurrent access to shared resources and avoids race conditions.

ThreadSafetyExample.java

public class ThreadSafetyExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable runnable = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("Final Count: " + counter.getCount());
    }
}
class Counter {
    private int count = 0;
    // Synchronized method to ensure thread safety
    public synchronized void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}

Output:

Final Count: 2000

In the Counter class, both the increment() and getCount() methods are declared as synchronized. This ensures that only one thread can execute these methods at a time, preventing concurrent modification of the count field.

ThreadSafety.java

public class ThreadSafety {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable runnable = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("Final Count: " + counter.getCount());
    }
}
class Counter {
    private int count = 0;
    // Synchronized method to ensure thread safety
    public synchronized void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}

Output:

Final Count: 2000

In this program, two threads execute the increment() method of the Counter object concurrently. The join() method ensures that the main thread waits for both threads to complete before printing the final count. The output will be 2000, indicating that the operations were executed safely and the count was incremented correctly.

3. Reentrant Locks:

While the synchronized keyword provides a convenient way to achieve thread safety, another option is to use explicit locks from the java.util.concurrent.locks package. The ReentrantLock class is a widely used lock implementation that provides more flexibility and control compared to intrinsic locks.

ThreadSafetyExample.java

public class ThreadSafetyExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable runnable = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("Final Count: " + counter.getCount());
    }
}
class Counter {
    private int count = 0
    // Synchronized method to ensure thread safety
    public synchronized void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}

Output:

Final Count: 2000

In this example, the ReentrantLock is used to guard the critical sections of code in the increment() and getCount() methods. The lock() method acquires the lock, and the unlock() method releases it. The finally block ensures that the lock is always released, even if an exception occurs within the critical section.

In Summary, Thread safety is an essential aspect of concurrent programming in Java. It ensures that shared resources are accessed in a controlled and predictable manner, preventing issues like race conditions and data corruption. In this section, we explored various techniques to achieve thread safety, including the use of immutable objects, synchronization with the synchronized keyword, and explicit locks with the ReentrantLock class.

Next Topicxxwxx.dll Virus Java 9

← prev next →