| Jakob Jenkov Last update: 2014-06-23
|
A 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.
By the way, in my Java Concurrency tutorial I have described how to implement your own locks, in case you are interested (or need it). See my text on Locks for more details.
译文:
java.util.concurrent.locks.Lock 就像synchronized 块一样是一种线程同步机制。
然而Lock比synchronized 块更精细更复杂。
顺便提一下,在我的 Java Concurrency tutorial 中我已经说明了如何去实现你自己的锁。如果你有所兴趣或者需要,接着看更多关于Lock 的细节。
Java Lock Example
Since Lock
is an interface, you need to use one of its implementations to use a Lock
in your applications. Here is a simple usage example:
Lock lock = new ReentrantLock();
lock.lock();
//critical section
lock.unlock();
First a Lock
is created. Then it's lock()
method is called. Now the Lock
instance is locked. Any other thread calling lock()
will be blocked until the thread that locked the lock calls unlock()
. Finally unlock()
is called, and the Lock
is now unlocked so other threads can lock it.
译文:
//critical section 临界区
首先创建一个Lock
。然后调用lock()方法。现在这个Lock
示例已经被锁定了。
其他任何的线程尝试去调用lock()方法都会阻塞,除非调用lock()方法的线程调用了unlock()方法释放了锁。
最后调用unlock()方法释放锁,其他线程可以调用lock()方法锁定一个示例 。
Java Lock Implementations
The java.util.concurrent.locks
package has the following implementations of the Lock
interface:
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. A
Lock
can have it's calls to lock()
and unlock()
in separate methods.
译文:
Java Lock的实现
java.util.concurrent.locks 包有Lock接口的几个实现:
Locks和
synchronized 块的主要不同点:
- synchronized 块无法保证等待进入它的线程的顺序。
- 无法将任何参数传递到synchronized 块。因此,希望通过超时去访问一个synchronized 块是不可行的。
- synchronized 块必须在一个方法中使用。
Lock
可以在不同的方法中调用lock()和unlock()。
Lock Methods
The Lock
interface has the following primary methods:
- lock()
- lockInterruptibly()
- tryLock()
- tryLock(long timeout, TimeUnit timeUnit)
- unlock()
The 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.
The 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.
The tryLock()
method attempts to lock the Lock
instance immediately. It returns true
if the locking succeeds, false if Lock
is already locked. This method never blocks.
The tryLock(long timeout, TimeUnit timeUnit)
works like the tryLock()
method, except it waits up the given timeout before giving up trying to lock the Lock
.
The unlock()
method unlocks the Lock
instance. Typically, a Lock
implementation 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 (RuntimeException
).