In Part 1 of this synchronization tutorial, we discussed the use of synchronized blocks and methods in Java to achieve thread safety. In this tutorial, we'll explore a different way to achieve synchronization using Lock and Condition objects.

Java provides the Lock interface and its implementation classes such as ReentrantLock and ReentrantReadWriteLock for exclusive and shared locks, respectively. Lock objects allow threads to acquire and release locks on a shared resource in a way that provides more flexibility than the synchronized keyword.

Lock objects are acquired and released explicitly, unlike synchronized blocks and methods, which are acquired and released automatically by the JVM. This explicit locking approach provides more control and flexibility in handling locks, as threads can attempt to acquire locks repeatedly until they are successful, and can release locks in a specific order.

To use a Lock object, we first create an instance of the Lock interface and then acquire and release the lock as needed. Here's an example:

Lock lock = new ReentrantLock();
lock.lock();
try {
    // Critical section of code
} finally {
    lock.unlock();
}

In this example, we create a new ReentrantLock object and call its lock() method to acquire the lock. Then, we execute the critical section of code, which is the code that must be executed atomically. Finally, we release the lock by calling the unlock() method.

If any exceptions are thrown while executing the critical section of code, the lock will still be released, thanks to the use of the finally block.

Another useful feature of Lock objects is the ability to create Condition objects. Condition objects provide a way for threads to wait for a certain condition to become true before continuing with their execution. Here's an example:

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

// Thread 1
lock.lock();
try {
    while (!conditionMet) {
        condition.await();
    }
    // Critical section of code
} finally {
    lock.unlock();
}

// Thread 2
lock.lock();
try {
    // Code that changes conditionMet
    condition.signal();
} finally {
    lock.unlock();
}

In this example, we create a new Condition object using the newCondition() method of the Lock object. Then, in Thread 1, we acquire the lock, and while the condition is not met, we wait for the condition using the await() method of the Condition object. Once the condition is met, we execute the critical section of code.

In Thread 2, we acquire the lock, change the value of conditionMet, and then signal the waiting thread using the signal() method of the Condition object.

Overall, the Lock and Condition objects provide a more flexible way to achieve synchronization in Java. By using Lock objects, we have finer-grained control over the acquisition and release of locks, and Condition objects allow us to wait for certain conditions to become true before continuing with our code.