- java.util.concurrent - Java Concurrency Utilities
- Java Fork and Join using ForkJoinPool
java.util.concurrent.locks.Lock is a thread synchronization mechanism just like
synchronized blocks. A
Lock is, however, more flexible and more sophisticated
than a synchronized block.
Java Lock Example
Lock is an interface, you need to use one of its implementations to use a
in your applications. Here is a simple usage example:
Lock lock = new ReentrantLock(); lock.lock(); //critical section lock.unlock();
Lock is created. Then it's
lock() method is called. Now the
instance is locked. Any other thread calling
lock() will be blocked until the thread that locked
the lock calls
unlock() is called, and the
now unlocked so other threads can lock it.
Java Lock Implementations
java.util.concurrent.locks package has the following implementations of the
Main Differences Between Locks and Synchronized Blocks
The main differences between a
Lock and a synchronized block are:
- A synchronized block makes no guarantees about the sequence in which threads waiting to entering it are granted access.
- You cannot pass any parameters to the entry of a synchronized block. Thus, having a timeout trying to get access to a synchronized block is not possible.
- The synchronized block must be fully contained within a single method.
Lockcan have it's calls to
unlock()in separate methods.
Lock interface has the following primary methods:
- tryLock(long timeout, TimeUnit timeUnit)
lock() method locks the
Lock instance if possible. If the
Lock instance is
already locked, the thread calling
lock() is blocked until the
Lock is unlocked.
lockInterruptibly() method locks the
Lock unless the thread calling the method has been interrupted.
Additionally, if a thread is blocked waiting to lock the
Lock via this method, and it is interrupted, it exits
this method calls.
tryLock() method attempts to lock the
Lock instance immediately. It returns
if the locking succeeds, false if
Lock is already locked. This method never blocks.
tryLock(long timeout, TimeUnit timeUnit) works like the
tryLock() method, except
it waits up the given timeout before giving up trying to lock the
unlock() method unlocks the
Lock instance. Typically, a
will only allow the thread that has locked the
Lock to call this method. Other threads calling this method
may result in an unchecked exception (