Java Synchronized

Java is a widely used programming language that allows developers to create powerful and efficient applications for a variety of platforms. In multi-threaded environments, where multiple threads can access the same data, synchronization is essential to ensure that the data remains consistent and correct. In Java, the synchronized keyword is used to ensure that only one thread at a time can access a block of code, thereby preventing concurrency issues.

Synchronization in Java

Synchronization in Java is used to control access to shared resources such as variables, objects, or methods. When multiple threads access shared resources simultaneously, it can lead to race conditions, deadlocks, and other concurrency issues. Synchronization ensures that only one thread can access the shared resource at a time, thereby preventing these issues.

The synchronized keyword in Java is used to specify that a block of code or a method is synchronized. When a thread enters a synchronized block or method, it acquires the lock on the object or class that the block or method belongs to. The lock prevents other threads from entering the synchronized block or method until the lock is released.

Syntax

The syntax of using the synchronized keyword in Java is as follows:

synchronized (object) {
   // Synchronized block of code
}

public synchronized void methodName() {
   // Synchronized method
}

In the first syntax, the synchronized keyword is used to specify that the block of code that follows is synchronized. The object parameter is the object that the block of code will synchronize on. This can be any Java object, but it is typically a shared resource that needs to be accessed in a synchronized manner.

In the second syntax, the synchronized keyword is used to specify that the method is synchronized. This means that only one thread can execute the method at a time. The method can belong to an object or a class.

Here is a simple example of Java synchronized code:

SynchronizedExample.java

public class SynchronizedExample {
    private int counter = 0;
    public synchronized void increment() {
        counter++;
    }
    public static void main(String[] args) throws InterruptedException {
        SynchronizedExample synchronizedExample = new SynchronizedExample();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                synchronizedExample.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                synchronizedExample.increment();
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("Counter: " + synchronizedExample.counter);
    }
}

Output:

Counter: 2000

In this example, we create a class SynchronizedExample with an instance variable counter that we want to increment in a synchronized manner. We define a method increment() that is synchronized using the synchronized keyword. This means that only one thread can execute this method at a time, ensuring that the counter is incremented in a thread-safe manner.

In the main method, we create two threads and pass a lambda expression to the Thread constructor. Each lambda expression contains a loop that increments the counter by calling the increment() method of the SynchronizedExample object.

We start both threads using the start() method, and then we wait for both threads to finish by calling the join() method on each thread. Finally, we print the value of the counter to the console.

The output indicates that both threads successfully incremented the counter a total of 1000 times each, resulting in a final value of 2000. Since we used the synchronized keyword to ensure that the increment method was executed by only one thread at a time, we can be sure that the counter was incremented in a thread-safe manner.

Benefits of Synchronization in Java

The synchronized keyword in Java provides several benefits, including:

Thread safety: Synchronization ensures that shared resources are accessed in a thread-safe manner, preventing concurrency issues such as race conditions and deadlocks.

Consistency: Synchronization ensures that shared resources are accessed consistently by all threads, preventing data inconsistencies and corruption.

Performance: While synchronization can have a slight impact on performance due to the overhead of acquiring and releasing locks, it is often more efficient than other concurrency control mechanisms such as semaphores and monitors.

Limitations of Synchronization in Java

While the synchronized keyword in Java is a powerful tool for managing concurrency, it has some limitations:

Deadlocks: If two threads are waiting for each other to release locks, a deadlock can occur, leading to a halt in the application.

Performance impact: Synchronization can have a slight impact on performance, particularly in highly concurrent environments where many threads are accessing shared resources simultaneously.

Limited scope: Synchronization only works on synchronized blocks of code and methods. It does not provide a mechanism for managing concurrency at a higher level, such as across multiple classes or threads.

Conclusion

Synchronization is an essential feature of Java that enables developers to create thread-safe and efficient applications. The synchronized keyword is a powerful tool for managing concurrency and preventing race conditions, deadlocks, and other concurrency issues. While it has some limitations, synchronization is often the most efficient and effective way to manage shared resources in multi-threaded environments.

Next TopicTypes of Arithmetic Operators in Java

← prev next →