章节目录
什么是重入锁
底层实现 - 如何实现重入
公平与非公平获取锁的区别与底层实现
1. 什么是重入锁
1.1 重入锁的定义
重入锁 ReentrantLock, 支持重入的锁, 表示一个线程对资源的重复加锁.
1.2 重入锁的特性
重进入
非 / 公平性获取锁
1.3 自定义同步器 Mutex 的缺陷
当线程调用 Mutex 的 lock()方法获取锁之后, 再次调用 lock()方法, 该线程将会被
自己阻塞, 原因是 Mutex 在实现 tryAcquire(int acquires)方法时没有考虑占有锁
的线程再次获取锁的场景.
1.4 ReentrantLock & synchronized 关键字
1.synchronized 关键字支持隐式的重进入
2.ReentrantLock 在调用 lock() 方法时, 已经获取到锁的线程, 能够再次调用
lock()方法获取到锁而不被阻塞, 即可支持重入
1.4 公平性获取锁
公平性 | 含义 |
---|---|
公平性获取锁 | 在绝对时间上,先对锁进行获取请求的请求一定先被满足,那么这个锁就是公平的 |
非公平性获取锁 | 无上述限制 |
事实上 公平锁机制往往没有非公平性机制获取锁的效率高, 因为会牵扯到频繁的上下文切换, 但公平锁可以减少饥饿发生的概率, 等待越久的请求越能得到优先满足.
2. 底层实现 - 如何实现重入
重进入是指任意线程在获取到锁之后能够再次获取该锁, 而不被阻塞, 改特性实现需要解决以下两个问题:
线程再次获取锁
线程再次获取锁. 锁需要去识别获取锁的线程是否为当前占据锁的线程, 如果是, 则再次成功获取.
锁的最终释放
线程重复 n 次获取了锁, 随后在第 n 次释放锁, 锁的释放要求锁对于被获取递
增的次数进行递减操作, 当计数 ==0 时表示锁已经成功释放.
2.1 可重入锁的源码
非公平性获取同步状态 (锁) 的 nonfairTryAcquire() 方法
- final boolean nonfairTryAcquire(int acquires) {
- final Thread current = Thread.currentThread();
- int c = getState();
- if (c == 0) {
- if (compareAndSetState(0, acquires)) {
- setExclusiveOwnerThread(current);
- return true;
- }
- }
- else if (current == getExclusiveOwnerThread()) {
- int nextc = c + acquires;
- if (nextc < 0) // overflow
- throw new Error("Maximum lock count exceeded");
- setState(nextc);
- return true;
- }
- return false;
- }
该方法增加了再次获取同步状态的处理逻辑: 通过判断当前线程是否为获取锁的线程来决定获取操作是否成功, 如果是获取锁的线程的再次请求 则将同步状态值计数器进行递增并返回 true, 表示获取同步状态成功.
释放同步状态(锁)
- protected final boolean tryRelease(int releases) {
- int c = getState() - releases;
- if (Thread.currentThread() != getExclusiveOwnerThread())
- throw new IllegalMonitorStateException();
- boolean free = false;
- if (c == 0) {
- free = true;
- setExclusiveOwnerThread(null);
- }
- setState(c);
- return free;
- }
如果该锁被获取了 n 次, 那么前 n-1 此 tryRelease(int release) 方法必须返回 false, 而只有同步状态完全释放了, 才能返回 true.
3. 公平与非公平获取锁的区别与底层实现
3.1 公平性获取锁的底层实现
公平性获取锁即按照客观时间顺序, FIFO 方式获取同步状态
具体源码如下所示
- protected final boolean tryAcquire(int acquires) {
- final Thread current = Thread.currentThread();
- int c = getState();
- if (c == 0) {
- if (!hasQueuedPredecessors() &&
- compareAndSetState(0, acquires)) {
- setExclusiveOwnerThread(current);
- return true;
- }
- }
- else if (current == getExclusiveOwnerThread()) {
- int nextc = c + acquires;
- if (nextc < 0)
- throw new Error("Maximum lock count exceeded");
- setState(nextc);
- return true;
- }
- return false;
- }
公平性获取同步状态的与非公平性获取同步状态的区别在于 hasQueuedPredecessors()方法的使用, 即加入了当前节点是否有前驱节点的判断, 如果该方法返回 true, 则表示有线程比当前线程更早的加入到同步队列(更早的请求获取锁), 因此需要等待前驱线程获取并释放锁之后才能继续获取锁.
非公平性获取锁的实现
公平性获取锁保证了锁的获取顺序按照 FIFO 原则, 不会出现线程 "饥饿" 的现象, 但代价是进行大量的线程切换.
非公平性锁虽然可能造成线程饥饿, 但是有极少的线程切换, 保证了其更大的吞吐量.
来源: http://www.jianshu.com/p/00e5ba66cf16