Java Method and Block Synchronization

Synchronization in Java is used to control access to shared resources in a multithreaded environment. It ensures that only one thread executes a critical section at a time, preventing data inconsistency.

• Can be applied to methods or specific blocks of code
• Method synchronization locks the entire method
• Block synchronization locks only the critical section

Types of Synchronization

Synchronization in Java can be applied in different ways depending on the level of control required. It helps manage thread access to shared resources efficiently.

1. Method Synchronization

To synchronize a method, add the synchronized keyword. This ensures that only one thread can execute the method at a time.

Example: Unsynchronized Method

Output:

0
0
1
2
1
2

Explanation: Threads t1 and t2 access the method concurrently, causing mixed output.

Example: Synchronized Method

0
1
2
0
1
2

Explanation: Only one thread executes the method at a time, ensuring data consistency.

2. Block Synchronization

Block synchronization is used when only part of a method contains critical code. This improves performance by allowing threads to execute non-critical code concurrently.

Example: Synchronized Block

Mohit

Explanation: Only the block updating name and count is synchronized. Adding names to the list runs concurrently.

Method vs Block Synchronization

Important Points

• A thread entering a synchronized method/block acquires a lock, it releases it upon exit.
• Instance methods/blocks: Acquire object-level lock.
• Static methods/blocks: Acquire class-level lock.
• Synchronization on null objects throws NullPointerException.
• wait(), notify(), and notifyAll() are key methods in synchronization.
• Avoid synchronizing non-final fields to prevent threads from locking different objects.
• synchronized keyword cannot be applied to variables.

Advantages

• Ensures mutual exclusion for shared resources in multithreaded programs.
• Both synchronized instance and static methods can run concurrently because they lock different objects.

Limitations

• Prevents concurrent reads, limiting concurrency.
• Synchronized methods can degrade performance. Prefer block synchronization for critical sections only.