转载自
http://www.goldendoc.org/2011/06/lock_acquire_release/
上一篇文章中,我们对J.U.C做了了解,在这一篇文章我们将来以ReentrantLock为例,来分析一下锁的获取和释放的过程,让大家能够对锁的获取和释放的整体过程有一个了解。
一、锁的获取
先看下ReentrantLock的lock()方法,整个方法只有一行,调用acquire方法,看看acquire方法的实现:
1
2
3
4
5
|
public final void acquire( int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); } |
这段代码的实现也是比较简洁,先尝试一次tryAcquire操作,如果失败,则把当前线程加入到同步队列中去,这个时候可能会反复的阻塞与唤醒这个线程,直到后续的tryAcquire(看acquireQueued的实现)操作成功。
再看看tryAcquire的实现:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
protected final boolean tryAcquire( int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0 ) { if (isFirst(current) && 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 ; } |
这段代码是尝试获取锁的过程,它先判断当前的AQS的state值,如果为0,则表示该锁没有被持有过,如果这个时候同步队列是空的或者当前线程就是在同步队列的头部,那么修改state的值,并且设置排他锁的持有线程为当前线程
如果大于0,则判断当前线程是否是排他锁的持有线程,如果是,那么把state值加1(注意state是int类型的,所以state的最大值是就是int的最大值)
如果第一次tryAcquire()操作失败,那么就把当前线程加入到等待队列中去,看addWaiter()方法:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
private Node addWaiter(Node mode) { Node node = new Node(Thread.currentThread(), mode); // Try the fast path of enq; backup to full enq on failure Node pred = tail; if (pred != null ) { node.prev = pred; if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } enq(node); return node; } |
这段代码中先尝试了一下了下enq()方法中等待队列不为空的情况,如果失败,再调用enq()方法将当前线程加入等待队列,enq()的过程我们已经在上一篇文章中讲过了,不再赘述。
最后在当前线程被加入到等待队列中去以后,再调用acquireQueued去获取锁,看看acquireQueued的代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
final boolean acquireQueued( final Node node, int arg) { try { boolean interrupted = false ; for (;;) { final Node p = node.predecessor(); if (p == head && tryAcquire(arg)) { setHead(node); p.next = null ; // help GC return interrupted; } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true ; } } catch (RuntimeException ex) { cancelAcquire(node); throw ex; } } |
这段代码中拿到当前线程在同步队列中的前面一个节点,如果这个节点是是头部,那么马上进行一次tryAcquire操作,如果操作成功,那么把当前线程弹出队列,整个操作就此结束。如果这个节点不是头部或者说tryAcquire操作失败的话,那么就判断是不是要将当前线程给阻塞掉(shouldParkAfterFailedAcquire)方法:判断当前线程是否应该被阻塞掉,实际上判断的是当前线程的前一个节点的状态,如果前一个节点的状态小于0(condition或者signal),那么返回true,阻塞当前线程;如果前一个节点的状态大于0(cancelled),则向前遍历,直到找到一个节点状态不大于0的节点,并且将中间的cancelled状态的节点全部踢出队列;如果前一个节点的状态等于0,那么将其状态置为-1(signal),并且返回false,等待下一次循环的时候再阻塞。
整个锁的获取过程就是这样,我们再来总结一下整个过程:acquire()方法会先调用一次tryAcquire方法获取一次锁,如果失败,则把当前线程加入到等待队列中去,然后再调用acquireQueued获取锁,acquireQueued在当前节点不在头部的时候会把当前线程的前一个结点的状态置为SIGNAL,然后阻塞当前线程。当当前线程到了队列的头部的时候,那么获取锁的操作就会成功返回。
二、锁的释放
首先,我们知道在acquireQueued方法中,如果一个线程成功获取到了锁,那么它就应该是整个等待队列的head节点,然后,我们再来看一看unlock()方法,和lock()方法一样,unlock()方法也是只有一行代码,直接调用release()方法,我们看看release()方法的实现:
1
2
3
4
5
6
7
8
9
|
public final boolean release( int arg) { if (tryRelease(arg)) { Node h = head; if (h != null && h.waitStatus != 0 ) unparkSuccessor(h); return true ; } return false ; } |
这个过程首先调用tryRelease方法,如果锁已经完全释放,那么就唤醒下一个节点,先来看看tryRelease方法:
1
2
3
4
5
6
7
8
9
10
11
12
|
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; } |
这段代码首先获取当前AQS的state状态并且将其值减一,如果结果等于0(锁已经被完全释放),那么将排他锁的持有线程置为null。将AQS的state状态置为减一后的结果。
然后再看看唤醒继任节点的代码:
1
2
3
4
5
6
7
8
9
10
11
12
|
private void unparkSuccessor(Node node) { compareAndSetWaitStatus(node, Node.SIGNAL, 0 ); Node s = node.next; if (s == null || s.waitStatus > 0 ) { s = null ; for (Node t = tail; t != null && t != node; t = t.prev) if (t.waitStatus <= 0 ) s = t; } if (s != null ) LockSupport.unpark(s.thread); } |
这段代码先清除当前节点的waitStatus为0,然后判断下一个节点是不是null或者cancelled的状态,如果是,则从队列的尾部往前开始找,找到一个非cancelled状态的节点,最后唤醒这个节点。
最后 ,总结一下释放操作的整个过程:其实整个释放过程就做了两件事情,一个是将state值减1,然后就是判断锁是否被完全释放,如果被完全释放,则唤醒继任节点。
三、整体过程描述
看了上面的锁的获取与释放操作以后,整体过程还是比较清晰的,在文章的最后,我们把获取与释放操作串在一起在简单看一下:
- 获取锁的时候将当前线程放入同步队列,并且将前一个节点的状态置为signal状态,然后阻塞
- 当这个节点的前一个节点成功获取到锁,前一个节点就成了整个同步队列的head。
- 当前一个节点释放锁的时候,它就唤醒当前线程的这个节点,然后当前线程的节点就可以成功获取到锁了
- 这个时候它就到整个队列的头部了,然后release操作的时候又可以唤醒下一个。
相关推荐
Java面试题+Java并发编程(J.U.C)+Java8实战+Redis+kafka Java 『必看』2021 版最新Java 学习路线图(持续刷新):+1::+1::+1: Java入门面试题 Java基础入门80问,适合新手,老鸟直接跳过 Java并发编程(J.U.C) ...
Java并发编程实践.pdf Java并发编程实践.pdf Java并发编程实践.pdf Java并发编程实践.pdf
Java 并发编程实战.pdf 目录齐全
《Java并发编程实战》是一本完美的Java并发参考手册。书中从并发性和线程安全性的基本概念出发,介绍了如何使用类库提供的基本并发构建块,用于避免并发危险、构造线程安全的类及验证线程安全的规则,如何将小的线程...
JAVA并发编程实战.pdf-详细介绍了线程并发的机制的
Java并发编程实战.pdf 自己做了书签查看方便
Joshua Bloch是Google的首席Java架构师,《Effective Java》的作者、《3ava PLizzlers》的合著者,他不像他的兄弟(his brother,Bloctl与Neal主持的Java编程专栏里虚构的人物)那样编程,从来都不。Doug Lea是...
《Java并发编程实战》深入浅出地介绍了Java线程和并发,是一本完美的Java并发参考手册。书中从并发性和线程安全性的基本概念出发,介绍了如何使用类库提供的基本并发构建块,用于避免并发危险、构造线程安全的类及验证...
java并发编程pdf文档第二部分:Java并发编程实战.pdf、Java多线程编程核心技术.pdf、实战Java高并发程序设计.pdf
JAVA并发编程与高并发解决方案-并发编程四之J.U.C之AQS.docx
JAVA并发编程实践.pdf+高清版+目录 书籍源码
JAVA并发编程实践.pdf 带目录书签 清晰版
Java并发编程与高并发解决方案之并发容器(J.U.C).docx
Java并发核心编程.pdf
java并发编程艺术.azw3