J·U·C Java并发包
JUC 是java.util.concurrent的简称,在jdk 1.5时被引入,JUC包的主要作者是并发大师Doug Lea,包含了非常多的并发编程工具类,其中有一个叫做AbstractQueuedSynchronizerd的抽象类,这个类通常被称为AQS,这是一个非常重要的类,可以说是整个JUC并发包的根基之一,它抽象了与线程同步和协作相关的最核心逻辑,很多并发工具类都是基于AQS来实现的,比如最常用的ReentrantLock、CountDownLatch、Semaphore等等。
AQS的核心是两个双向链表队列(同步队列和等待队列)和一个同步状态,同步队列用来记录获取同步状态失败的线程,等待队列用来获取在Condition接口上调用await()方法的线程,同步状态是一个int类型的变量,在不同的实现中有不同的含义。下面以ReentrantLock的独占锁为例来聊聊AQS的原理,关于共享模型、可中断模式、超时模式的实现原理,实际上本质区别不大,限于篇幅,后面再说。
ASQ在ReentrantLock中的应用
ReentrantLock是一种显示锁,作用与synchronized一样,用来做资源的同步,保证共享资源的线程安全,使用范式如下:
Lock lock = new ReentrantLock();lock.lock();try { do something}finally { lock.unlock();}
ReentrantLock有两种模式,一种是公平模式,一种是非公平模式,为了不引入其他的逻辑,这里以默认的非公平锁为例来看看lock()和unlock()的原理。
先来看看RenntrantLock与AQS之间的关系:
public class ReentrantLock implements Lock, java.io.Serializable { abstract static class Sync extends AbstractQueuedSynchronizer { abstract void lock(); protected final boolean isHeldExclusively() { .. } final ConditionObject newCondition() { return new ConditionObject(); } protected final boolean tryRelease(int releases) { .. } final boolean nonfairTryAcquire(int acquires) { ... } } static final class NonfairSync extends Sync { final void lock() { ... } protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); } } static final class FairSync extends Sync { final void lock() { acquire(1); } protected final boolean tryAcquire(int acquires) { .. } }}
可以看到,Sync继承自AQS,利用Sync实现了公平和非公平两种同步锁,同步队列中的结构如下:
+------+ prev +-----+ +-----+ head | |
加锁过程
下面聚焦到lock这个方法上。
ReentrantLockpublic void lock() { sync.lock(); } NonfairSync final void lock() /** 这里一进来就以cas的方式抢占同步状态 如果当前同步状态值为0,并且成功将其设置为1 则当前线程成功获取锁,lock方法返回。 这里也体现了锁的非公平性: 公平锁:严格按照锁的获取顺序来分配锁 非公平锁:不管后面有没有线程在等待锁资源,都会抢占同步状态 */ if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else /** 如何失败,则调用父类AQS的acquire方法 */ acquire(1); }
下面来看看AQS的acquire()方法:
public final void acquire(int arg) { /** 这里包含了AQS的完成逻辑 1. 尝试调用子类的tryAcquire()方法来获取同步状态值 (这里的获取同步状态就是将同步状态从0设置成1) 2. 如果设置失败,调用addWaiter方法,将当前节点构造成一个Node 节点,然后用cas的方式线程安全的添加到同步队列的末尾 3. 最后调用acquireQueued方法让当前线程进入自旋状态,获取同步状态 失败的话,利用LockSupport.park()方法将当前线程挂起,等待 前驱节点线程唤醒 */ if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }
我们一个方法一个方法的看,首先是子类(NonfairSync)的tryAcquire()方法:
protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires);}final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); //如果当前状态为0,说明锁没有被其他线程获取 if (c == 0) { //尝试设置同步状态,获取锁 if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } /** 这里处理锁d 可重入性。 可重入性指的是同一个线程多次调用同一个需要锁的方法时, 不应该被阻塞。 如果上次获取锁的线程是当前线程,就将同步状态+1 */ else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); //这里没有用cas,是因为,如果逻辑走到这里 //当面当前线程已经获取到了锁 setState(nextc); return true; } return false;}
这个方法主要是利用AQS实现了上层组件(ReentrantLock)的锁的语义。
下面再看addWaiter这个方法。
/** 走到这里,说明当先线程获取同步锁失败了*/private Node addWaiter(Node mode) { //创建一个同步队列中的Node节点 Node node = new Node(Thread.currentThread(), mode); // Try the fast path of enq; backup to full enq on failure /** 这里来了一个 fast try 去将当前这个node节点加入到同步队列的末尾 之所以这么做,是为了尽量避免进入下面enq的自旋, 如果这里设置失败了,再进入自旋状态,从这里也可以看出 Dong Lea的功力,对性能的极致要求 */ Node pred = tail; if (pred != null) { node.prev = pred; if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } //前面尝试失败了,就进入自旋cas模式 enq(node); return node;}private Node enq(final Node node) { for (;;) { Node t = tail; if (t == null) { // Must initialize if (compareAndSetHead(new Node())) tail = head; } else { node.prev = t; //这里就是尝试将tail设置成新增的节点 if (compareAndSetTail(t, node)) { t.next = node; return t; } } }}
最后,再来看看acquireQueued这个方法:
final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { boolean interrupted = false; /** 成功添加到同步队列以后,就进入了自选状态 */ for (;;) { /** 这里仍然不放弃,判断其前驱节点是否为头节点& 能够获取同步状态,如果true,则说明获取到锁 直接返回,跳出自旋 */ final Node p = node.predecessor(); if (p == head && tryAcquire(arg)) { setHead(node); p.next = null; // help GC failed = false; return interrupted; } /** 如果失败了,这里会做两件事 1、将其前驱节点状态设置为SINGAL,目的是让 前驱节点执行完成时,去通知当前节点唤醒 2、利用LockSupport.park()挂起当前线程 */ if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); }}
到这里,ReentrantLock 独占非公平锁的加锁的加锁过程就完成了,同步队列的状态如下图所示:
总结一下:
尝试获取同步状态;
如果成功,直接返回;
如果失败,构造一个Node节点,CAS+自旋将其线程安全的加入同步队列末尾;
然后每个节点代表的线程进入自旋,设置前驱节点状态为SINGAl并挂起,等待被前驱节点唤醒;
解锁过程
相比于加锁,解锁过程要简单的多,主要就是释放同步状态,下面看看unlock的逻辑:
ReentrantLockpublic void unlock() { sync.release(1); } AQSpublic final boolean release(int arg) { //这里调用子类实现,释放同步状态 if (tryRelease(arg)) { Node h = head; if (h != null && h.waitStatus != 0) //唤醒后面的节点 unparkSuccessor(h); return true; } return false; } ReentrantLock中非公平的实现: protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; //这里处理重入锁的多次加锁的问题 //只有当同步状态-为0时,才代表释放锁状态成功 if (c == 0) { free = true; setExclusiveOwnerThread(null); } setState(c); return free; }
到此,基于AQS的锁的获取和释放就说完了。