Java Lock Framework vs Thread Synchronization

In multithreaded Java programs, synchronization ensures that only one thread accesses shared resources at a time, preventing issues like race conditions and data inconsistency. It helps maintain data integrity and proper execution flow.

• Achieved using synchronized keyword or Lock framework
• Prevents race conditions and data corruption
• Ensures safe and consistent access to shared resources

Thread Synchronization

Thread synchronization is the simplest mechanism to control access to shared resources. Using the synchronized keyword, a thread can acquire a lock on an object or method, ensuring that only one thread executes the critical section at a time.

• Ensures safe access to shared resources by multiple threads.
• Prevents race conditions and data inconsistency.

Final Count (synchronized): 2000

Explanation:

• increment() is synchronized, so only one thread can execute it at a time.
• t1.join() and t2.join() ensure the main thread waits for both threads to finish.
• Without synchronized, the final count might be less than 2000 due to race conditions.

Lock Framework

The Lock framework, based on the Lock interface, provides explicit control over thread access. ReentrantLock is its most common implementation, offering features like manual locking/unlocking and non-blocking attempts with tryLock(), unlike synchronized blocks.

• Uses explicit locks (lock()/unlock()) for controlling access.
• Provides more flexibility than synchronized (e.g., tryLock, fairness).

Final Count (ReentrantLock): 2000

Explanation:

• lock.lock() manually acquires the lock before modifying the counter.
• The try-finally block ensures the lock is always released, even if an error occurs.
• This allows more control, such as checking lock availability (tryLock) or waiting with timeout.
• The program safely increments the counter to 2000, similar to synchronized.

Which One to Use?

Use synchronized when:

• The critical section is small and simple.
• Low contention between threads is expected.
• We want simpler, less verbose code.

Use Lock framework when:

• You need high concurrency or advanced control over threads.
• The program requires timed or interruptible locks.
• There are read-heavy operations that can benefit from ReentrantReadWriteLock.
• We want to implement fairness policies or need to avoid deadlocks explicitly.

Rule of Thumb: For simple scenarios, synchronized is enough. For scalable, complex multi-threading, prefer Lock framework.

Lock Framework vs Thread Synchronization