Both ReentrantLock and synchronized are used in Java to achieve thread safety and prevent multiple threads from accessing shared resources simultaneously. However, there are some differences between the two approaches:
Flexibility: ReentrantLock provides greater flexibility than synchronized. For example, it allows for interruptible locks, timed locks, and the ability to try to acquire a lock without blocking, whereas synchronized provides no such options.
Performance: ReentrantLock can perform better than synchronized in certain situations, especially in highly concurrent environments. This is because it allows for finer-grained control over locking, which can lead to less contention and better utilization of system resources.
Explicitness: ReentrantLock is more explicit than synchronized. With ReentrantLock, you explicitly acquire and release locks, whereas with synchronized this is done implicitly. This can make the code using ReentrantLock easier to read and understand.
Scope: synchronized locks have method-level or object-level scope, whereas ReentrantLock locks can have broader scopes. This allows for greater control over which parts of the code are protected by the lock.
Here is an example of using ReentrantLock to protect a shared resource:
import java.util.concurrent.locks.ReentrantLock;
public class Example {
private ReentrantLock lock = new ReentrantLock();
private int count = 0;
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}
And here’s the same code using synchronized:
public class Example {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
Note that in the synchronized example, the lock is implicitly acquired and released by the JVM when entering and exiting the synchronized methods. In the ReentrantLock example, the lock is explicitly acquired and released using the lock() and unlock() methods.
In summary, while synchronized provides a simpler and more concise way to achieve thread safety, ReentrantLock provides greater flexibility and can perform better in highly concurrent environments.