In Java, thread locks are implemented using the synchronized keyword and the java.util.concurrent.locks package.
The synchronized keyword is used to create a thread lock on a method or block of code. When a thread enters a synchronized method or block, it acquires the lock for the object or class associated with the method or block. Other threads that attempt to enter the same synchronized method or block are blocked until the lock is released.
For example, the following code demonstrates how to use the synchronized keyword to create a thread lock on a method:
|
1 2 3 4 5 6 7 |
public class MyClass { private int sharedResource; public synchronized void updateSharedResource() { sharedResource++; } } |
In this example, the updateSharedResource() method is marked as synchronized, which means that only one thread can execute the method at a time.
The java.util.concurrent.locks package provides several classes for creating thread locks, such as ReentrantLock, ReadWriteLock, StampedLock and Semaphore. These classes provide more fine-grained control over locking and can be useful in situations where the basic functionality provided by the synchronized keyword is not sufficient.
For example, the following code demonstrates how to use the ReentrantLock class to create a thread lock:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import java.util.concurrent.locks.ReentrantLock; public class MyClass { private int sharedResource; private final ReentrantLock lock = new ReentrantLock(); public void updateSharedResource() { lock.lock(); try { sharedResource++; } finally { lock.unlock(); } } } |
In this example, the updateSharedResource() method acquires the lock using the lock() method before updating the shared resource, and releases the lock using the unlock() method when it’s done.
It’s important to note that, overuse of thread locks can lead to deadlocks, where multiple threads are blocked, each waiting for one of the others to release a lock. These can be difficult to debug and should be avoided by carefully designing the system.