Method and Block Synchronization in Java

Among the challenges of multi-threaded programming is the management of concurrent access to shared resources. To solve this problem, Java, a language well-known for its strong multi-threading support, has built-in synchronisation methods.

Java synchronisation makes ensuring that different threads can use common resources or run important code segments without destroying the program's state or generating inconsistent data.

The synchronised keyword, which may be used on both methods and code blocks, is mainly used to do this. In order to design Java programmes that are both efficient and thread-safe, developers must comprehend and apply method and block synchronisation.

In this section, we will explore the distinctions, applications, and best practices for managing concurrency between method and block synchronisation.

Method Synchronization

Method synchronization is straightforward and involves using the synchronized keyword in the method declaration. When a method is declared synchronized, the thread must acquire the method's object's intrinsic lock before executing the method. Other threads attempting to invoke any synchronized method on the same object will be blocked until the lock is released.

 
public class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}   

In this example, the increment() method is synchronized, ensuring that only one thread can execute it at a time for a particular instance of Counter.

Block Synchronization

Block synchronization allows finer control over the synchronization process. Instead of synchronizing the entire method, you can synchronize only a part of the code. This is useful when only a small portion of the method needs synchronization, improving performance by allowing greater concurrency.

 
public class Counter {
    private int count = 0;
    private final Object lock = new Object();
    public void increment() {
        synchronized (lock) {
            count++;
        }
    }
    public int getCount() {
        return count;
    }
}   

Block Synchronization Java Program

File Name: SynchronizationDemo.java

 
import java.io.*; 
class ThreadSafeCount { 
    private int counter = 0; 
    public synchronized void increment() { 
        counter++; 
    } 
    public synchronized int getValue() { 
        return counter; 
    } 
} 
class SynchronizationDemo { 
    public static void main (String[] args) { 
        ThreadSafeCounter t = new ThreadSafeCounter(); 
        // Creating multiple threads to test synchronization
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                t.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                t.increment();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(t.getValue()); // Should print 2000
    } 
}   

Output:

Explanation

This Java programme shows how to manage concurrent access to a shared counter via synchronisation. To ensure thread-safe operations, the ThreadSafeCounter class has a private counter variable with synchronised increment() and getValue() methods.

A ThreadSafeCounter instance is created in the Synchronisation class's main function. Each of the two threads that are initiated increases the counter by 1000 times. The join() function makes sure that before reporting the final counter number, the main thread waits for both threads to finish.

Race situations are avoided by synchronisation, guaranteeing that 2000 will always produce the desired results.

Differences

Granularity: Method synchronization locks the entire method, whereas block synchronization can lock a specific section of code, providing finer control.
Performance: Block synchronization can be more efficient as it reduces the scope of the lock, allowing greater concurrency.
Flexibility: Block synchronization allows synchronization on different objects, which can be useful in complex scenarios.

Applications

Minimize Synchronization Scope: Only synchronize critical sections of code to improve performance.
Avoid Nested Locks: Nested synchronization can lead to deadlocks.
Prefer java.util.concurrent Packages: Use higher-level concurrency utilities like Lock, Semaphore, and ConcurrentHashMap for better performance and scalability.
Use Volatile Variables: For simple flags or state checks, volatile can be a lightweight alternative to synchronization.

Conclusion

Java synchronisation is necessary to control multiple threads' concurrent access to common resources. By locking entire procedures and guaranteeing sequential access and data consistency, method synchronisation makes thread safety easier to understand.

Block synchronisation, on the other hand, provides more precise control by enabling the synchronisation of particular code segments, improving performance by enabling higher concurrency.

Developing reliable and effective multi-threaded Java programmes requires selecting the right synchronisation approach, being aware of potential problems like deadlocks, and using synchronisation sparingly.

Next TopicNumber-complement-problem-in-java

← prev next →