J.U.C之AQS：源码解析独占式同步实现

本文主要是介绍J.U.C之AQS：源码解析独占式同步实现，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

获取独占式同步状态

 

整体流程图

 

入口函数

    public final void acquire(int arg) {/**子类实现tryAcquire能否获取的独占式同步状态*如果返回true则获取同步状态成功方法直接返回*如果返回false则获取同步状态失败进入if语句*/if (!tryAcquire(arg) &&//addWaiter创建一个独占式节点node,添加到CLH同步队列尾部.//acquireQueued自旋,CLH头部后置第一个节点线程尝试获取同步状态,成功则设置其为head节点.失败则阻塞acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

获取同步状态失败,添加节点到CLH同步队列尾部

创建节点node(类型是独占式),如果CLH同步队列初始化则将当前节点添加到同步队列尾部,如果CLH同步队列没有初始化则需要调用子函数enq创建一个CLH同步队列并将当前节点添加到CLH同步队列尾部.

      private Node addWaiter(Node mode) {// 1. 将当前线程构建成NodeNode node = new Node(Thread.currentThread(), mode);// 2. 判断尾节点是否为null,如果为null说明CLH同步队列未初始化Node pred = tail;if (pred != null) {// 2.2 将当前节点插入同步队列尾部node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}// 2.1. 当前同步队列尾节点为null，说明CLH同步队列未初始化,调用enqenq(node);return node;
}

2.2 将当前节点插入同步队列尾部

2.1 创建CLH队列并添加到CLH队尾(enq)

初始化开始时一个自旋,首先会获取尾部node,并判断是否为null,如果为null说明同步队列需要初始化,进入if语句创建一个空node节点,让首部和尾部节点都指向这个空节点.完成后重新进入自旋.此时按照之前判断尾部节点存在.我们会进入else语句将当前添加节点设置为tail节点.

private Node enq(final Node node) {for (;;) {Node t = tail;if (t == null) { // Must initialize//1. 构造头节点尾节点指向一个空节点if (compareAndSetHead(new Node()))tail = head;} else {// 2. node节点插入clh队列尾，CAS操作失败自旋尝试node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}
}

第一次循环进入if

第二次循环进入else,并return环跳出了这个自悬循环体系

 

自旋,CLH头部后置第一个节点线程尝试获取同步状态,成功则设置其为head节点.失败则阻塞

• 1 进入自旋
• 2 判断当前节点前置节点是否为head节点，如果是重新尝试调用tryAcquire获取同步状态
• 2-1-1 获取同步状态失败,就将当前节点和前驱节点作为参数交给shouldParkAfterFailedAcquire调用设置同步节点node中等待状态,如果shouldParkAfterFailedAcquire返回true,则调用parkAndCheckInterrupt()阻塞当前线程。如果shouldParkAfterFailedAcquire返回false,则重新进入自旋（同独占式同步相同）
• 2-1-2 如果节点线程被从阻塞中唤醒重新进入 步骤 1 (自旋)
• 2-2-1 如果调用tryAcquireShared获取同步状态成功,设置当前节点为head节点,并释放当前节点前置节点的指针,retun跳出自旋.

    final boolean acquireQueued(final Node node, int arg) {boolean failed = true;try {boolean interrupted = false;for (;;) {// 1. 获得当前节点的先驱节点final Node p = node.predecessor();// 2. 当前节点能否获取独占式锁                  // 2.1 如果当前节点的先驱节点是头结点并且成功获取同步状态，即可以获得独占式锁if (p == head && tryAcquire(arg)) {//并将当前节点设置为head节点setHead(node);//释放当前节前驱节点指针(这里前驱节点也相当于原始的head节点)等待GC回收p.next = null; // help GCfailed = false;return interrupted;}// 2.2 获取锁失败，线程进入等待状态等待获取独占式锁if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}
}

shouldParkAfterFailedAcquire

参数

• 当前节点和前驱节点

返回

• true 调用parkAndCheckInterrupt()阻塞当前线程
• false 则重新进入acquireQueued自旋

逻辑

• 1 如果发现前置节点等待状态waitStatus==1则说明此客户不在等待剔除出队列，返回false,在外层自悬循环 中从node重新向前开始查找。

• 2 如果发现前置节点等待状态waitStatus==-1 返回true 调用parkAndCheckInterrupt()阻塞当前线程

• 3 如果发现前置节点等待状态waitStatu==0设置为waitStatus=-1，返回false,则重新进入acquireQueued自旋

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {int ws = pred.waitStatus;//前置节点状态为-1 返回true 准备直塞当前节点线程if (ws == Node.SIGNAL)return true;//前置节点状态为 1，剔除出队列，在外层自旋循环    中从新开始查找  返回falseif (ws > 0) {do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;//前置节点状态为 0，设置为 -1  在外层自旋循环    中从新开始查找  返回false   } else {/** waitStatus must be 0 or PROPAGATE.  Indicate that we* need a signal, but don't park yet.  Caller will need to* retry to make sure it cannot acquire before parking.*/compareAndSetWaitStatus(pred, ws, Node.SIGNAL);}return false;}

第一次循环

是第3种情况，并且这个方法运行后返回false。会当前节点(一般式尾节点)的前置节点等待状态由0变成了-1

第二次循环
是第2种情况 ，返回true开始阻塞线程，并设置线程中断
阻塞当前线程

    private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();}

 

释放独占式同步状态

 

整体图

入口函数

    public final boolean release(int arg) {/**子类实现能否释放的独占式同步状态*如果返回true则表示释放同步状态准入条件成功进入if语句*如果返回false则表示释放同步状态失败返回false*/if (tryRelease(arg)) {//判断CLH是否存在等待节点Node h = head;  if (h != null && h.waitStatus != 0)  //更新CLH同步队列Head节点的等待状态并对Head节点后置节点的线程从阻塞状态中唤醒unparkSuccessor(h);  return true;  }  return false;  }  

从head开始选择被唤醒线程节点,唤醒其中线程阻塞.设置head等待状态为初始状态0

    private void unparkSuccessor(Node node) {/** 将Head节点的等待状态设置为0*/int ws = node.waitStatus;if (ws < 0)compareAndSetWaitStatus(node, ws, 0);//默认情况下释放的节点为head节点后置节点s./** 如果head节点后置节点等待状态为1(取消),从尾节点开始遍历寻找最接近head节点等待状态为-1或0的节点作为释放节点s*/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;}//唤醒s节点中线程阻塞if (s != null)//后继节点不为null时唤醒该线程LockSupport.unpark(s.thread);
}
}  

第一步：获取head节点的waitStatus，如果小于0，就通过CAS操作将head节点的waitStatus修改为0，现在是：

第二步：寻找head节点的下一个节点，如果这个节点的waitStatus小于0，就唤醒这个节点，否则遍历下去，找到第一个waitStatus<=0的节点，并唤醒。

第三步: 重新进入acquireQueued方法2-1-2步骤,重新进入自旋尝试获取同步状态,如果成功则设置当前节点为head节点.原始head节点出队.

ps:可能有同学会对新head节点的thread=null有疑问，可以在AQS的setHead()方法实现中找到答案。

    /*** Sets head of queue to be node, thus dequeuing. Called only by* acquire methods.  Also nulls out unused fields for sake of GC* and to suppress unnecessary signals and traversals.** @param node the node*/private void setHead(Node node) {head = node;node.thread = null;node.prev = null;}

 

调用完毕后，acquireQueued返回false。并且现在thread2自由了。到此，已经全部分析完毕。

 

这篇关于J.U.C之AQS：源码解析独占式同步实现的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---