1. AQS共享模式
前面已经说过了AQS的原理及独享模式的源码分析，今天就来学习共享模式下的AQS的几个接口的源码。
首先还是从顶级接口acquireShared()方法入手：
public final void acquireShared(int arg) { if (tryAcquireShared(arg) < 0) doAcquireShared(arg); }
与acquire（）方法一样，tryAcquireShared（）为自己是实现的对资源获取的接口，AQS对返回值的语义已经定义好了，小于0表示失败，0表示成功，但是没有剩余资源，大于0表示成功，且还有剩余资源，其他线程还可以去获取，所以这里的流程就是，先调用tryAcquireShared()；当不能获取资源时，调用doAcquireShared()方法让线程进入等待队列。
doAcquireShared(int)方法，该方法用于将当前线程放入到等待队列中等待，直到其他线程唤醒并成功获取到资源才开始执行。源码如下：
private void doAcquireShared(int arg) { final Node node = addWaiter(Node.SHARED); boolean failed = true; try { boolean interrupted = false; for (;;) { final Node p = node.predecessor(); if (p == head) { int r = tryAcquireShared(arg); if (r >= 0) { setHeadAndPropagate(node, r); p.next = null; // help GC if (interrupted) selfInterrupt(); failed = false; return; } } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); }
将当前线程加入到等待队列队尾，并返回当前线程所在的节点，标记是否成功，判断是否被中断，获取当前节点的前驱，如果前驱不为空，如果前驱等于头节点，则表示当前线程被唤醒，因为头节点是持有资源的线程，当前节点可能会被头节点唤醒，尝试去获取资源，r>=0,表示获取成功，将当前节点设置为头节点，如果还有资源可以尝试唤醒下一个等待线程。判断是够被中断过，如果中断过，则清除中断标记，shouldParkAfterFailedAcquire()判断线程状态是否可以等待并找一个能够被唤醒的点进入等待，等着被unpark()或interrupt()，parkAndCheckInterrupt()使线程被waiting。
跟独占模式相比，这里是将selfInterrupt()放到了doAcquireShared()中，具体为啥我也不知道，但是这里的问题是，当第一个线程执行完之后释放资源，可能释放的资源只有3个，但是当前线程需要4个，而后面一个线程只需要2个，再后一个线程只需要1个，这种情况下，当前线程也是不会去唤醒后两个线程的，它会继续等待着其他的线程释放资源，独享模式下这样没问题，但是在共享模式下，多个线程可以同时执行，这样的策略会使得后面的两个线程会因为没被唤醒而没法执行，其实也算是问题，这里是cas严格保证了入队顺序和出对顺序，降低了并发，但是却是保证了安全的。
setHeadAndPropagate（Node, int）是将当前线程设置为头节点，当资源还有剩余的情况下去唤醒其他资源。
private void setHeadAndPropagate(Node node, int propagate) { Node h = head; // Record old head for check below setHead(node); /* * Try to signal next queued node if: * Propagation was indicated by caller, * or was recorded (as h.waitStatus either before * or after setHead) by a previous operation * (note: this uses sign-check of waitStatus because * PROPAGATE status may transition to SIGNAL.) * and * The next node is waiting in shared mode, * or we don't know, because it appears null * * The conservatism in both of these checks may cause * unnecessary wake-ups, but only when there are multiple * racing acquires/releases, so most need signals now or soon * anyway. */ if (propagate > 0 || h == null || h.waitStatus < 0 || (h = head) == null || h.waitStatus < 0) { Node s = node.next; if (s == null || s.isShared()) doReleaseShared(); } }
setHead将当前节点设置为头节点，当资源还有剩余的情况下，唤醒当前节点的相邻节点。
共享模式的流程就是尝试获取资源，获取资源失败，则进入等待，与独享模式相比，共享只是多了在资源剩余的情况下去唤醒其他线程的操作而已。
releaseShared()共享模式下释放共享资源的顶级入口，释放指定量的资源，如果成功释放且允许唤醒其他线程来获取资源，则它会唤醒队列里的其他等待线程来获取资源，源码：
public final boolean releaseShared(int arg) { if (tryReleaseShared(arg)) { doReleaseShared(); return true; } return false; }
调用tryReleaseShared()尝试释放资源，这里的tryReleaseShared()也是自己实现的，成功，则调用doReleaseShared()唤醒后继节点，
doReleaseShared（）用于唤醒后继节点
源码：
private void doReleaseShared() { /* * Ensure that a release propagates, even if there are other * in-progress acquires/releases. This proceeds in the usual * way of trying to unparkSuccessor of head if it needs * signal. But if it does not, status is set to PROPAGATE to * ensure that upon release, propagation continues. * Additionally, we must loop in case a new node is added * while we are doing this. Also, unlike other uses of * unparkSuccessor, we need to know if CAS to reset status * fails, if so rechecking. */ for (;;) { Node h = head; if (h != null && h != tail) { int ws = h.waitStatus; if (ws == Node.SIGNAL) { if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) continue; // loop to recheck cases unparkSuccessor(h); } else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) continue; // loop on failed CAS } if (h == head) // loop if head changed break; } }
自旋，通过unparkSuccessor（）唤醒后继节点，这样就释放掉了资源。
以上就是关于AQS共享模式的源码的分析。
2. CountDownLatch的使用及原理
CountDownLatch是jdk并发包中提供的负责并发编程的类，它也是AQS中共享模式的一种运用，利用它可以实现类似于计数器的功能，比如当以个线程需要等待其他几个线程的结果，但是其他几个线程又需要并行的执行时，就可以利用该类来实现，这里我们以一个求和的程序来举例该类的用法，
2.1 使用方式
存在一个文件中有如下数据
12,13,20,40 50,60,80,90 50,23,40 16,13
我们需要每一行用一个线程来进行加法计算，当所有线程执行完成后，将所有线程计算结果做一次汇总，实现如下：
计算每一行之和的代码：
public void calc (String line, int index, CountDownLatch countDownLatch) { String[] nus = line.split(","); int total = 0; for (String n : nus) { total += Integer.parseInt(n); } nums[index] = total; System.out.println(Thread.currentThread().getName() + " 执行计划任务..." + line + " 结果为：" + total); countDownLatch.countDown(); }
每一个线程执行计算完毕后都会调用countDownLatch.countDown();使得当前运行线程减一
计算总和的代码：
public void sum () { System.out.println(Thread.currentThread().getName() + "汇总线程开始执行..."); int total = 0; for (int i = 0; i < nums.length; i++) { total += nums[i]; } System.out.println("总结果为：" + total); }
计算每一行之和的调用方式和计算总和的调用方式：
package com.wangx.thread.t7; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; public class AddMain { public static void main(String[] args) { //读取文件 final List<String> contents = readFile(); //初始化countDownLatch 有几个线程执行构造参数就传几个 final CountDownLatch countDownLatch = new CountDownLatch(contents.size()); int lineNum = contents.size(); final AddNumber addNumber = new AddNumber(lineNum); //多个线程同时执行 for (int i = 0; i < lineNum; i++) { final int k = i; new Thread(new Runnable() { @Override public void run() { addNumber.calc(contents.get(k), k, countDownLatch); } }).start(); } //等待着直到所有线程执行完之后执行下面的代码 try { countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } //执行汇总 addNumber.sum(); } private static List<String> readFile() { List<String> contents = new ArrayList<>(); String line = null; try { BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\JavaDev\spring\thread\src\com\wangx\thread\t7\numers.txt")); while ((line = bufferedReader.readLine()) != null) { contents.add(line); } } catch (Exception e) { e.printStackTrace(); } return contents; } }
先初始化CountDownLatch实例，构造参数为需要并行执行的线程个数，调用await()方法等待，知道所有并行执行的线程执行完成。
2.2 实现原理（源码分析）
首先看初始化的构造方法：
public CountDownLatch(int count) { if (count < 0) throw new IllegalArgumentException("count < 0"); this.sync = new Sync(count); }
它实例化了一个内部同步器Sync,我们继续看Sync的构造：
Sync(int count) { setState(count); }
这里调用了AQS的方法，直接设置了AQS的状态，达到了初始化多少个资源的目的，因为AQS是提供一个原子的int类型state来维护状态的,我们的示例中初始化了contents.size（）个资源，接下来看countDown()方法，
public void countDown() { sync.releaseShared(1); }
调用releaseShared()来释放资源，这是AQS原理的运用，我们这里主要看在CountDownLatch中tryReleaseShared()方法的实现：
protected boolean tryReleaseShared(int releases) { // Decrement count; signal when transition to zero for (;;) { int c = getState(); if (c == 0) return false; int nextc = c-1; if (compareAndSetState(c, nextc)) return nextc == 0; } } }
实现也很简单，状态为0,资源已经被释放，自旋，更改状态，示例当contents个线程调用countDown完毕之后nextc == 0;才会成立，此时的releaseShared（）才回去唤醒其他的等待的线程，示例中是主线程在调用求和的方法。
await()方法：
public void await() throws InterruptedException { sync.acquireSharedInterruptibly(1); }
同样是调用内部同步器的方法来执行，
acquireSharedInterruptibly（）：
public final void acquireSharedInterruptibly(int arg) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); if (tryAcquireShared(arg) < 0) doAcquireSharedInterruptibly(arg); }
该方法的功能是获取当前获取资源，如果获取资源失败，则调用doAcquireSharedInterruptibly（）将线程放入到等待队列中等待，
doAcquireSharedInterruptibly（）与doAcquireShared（）相似，看源码：
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException { final Node node = addWaiter(Node.SHARED); boolean failed = true; try { for (;;) { final Node p = node.predecessor(); if (p == head) { int r = tryAcquireShared(arg); if (r >= 0) { setHeadAndPropagate(node, r); p.next = null; // help GC failed = false; return; } } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) throw new InterruptedException(); } } finally { if (failed) cancelAcquire(node); } }
两段代码都与前面共享模式时的doAcquireShared()方法功能相同，只是它是一个可中断的实现。
这就是CountDownLatch的实现原理，先初始化资源状态，每个线程执行完成后将释放资源，更改状态，直到最后一个执行的线程释放完资源，此时状态为0时，尝试去唤醒等待的线程，也就是执行countdown·.await()的线程。
这里就分享完了AQS的共享模式已经CountDownLatch的使用及原理，限于笔者水平有限，文中错误之处希望各位能够指出，谢谢！