Semaphore和CountDownLatch都是典型的共享锁，内部使用AbstractQueuedSynchronizer来实现共享锁的功能。
我们先回顾一下AQS中关于共享锁的重要方法。
一. AQS共享锁的重要方法
1.1 acquireShared系列获取共享锁的方法
// 获取共享锁
public final void acquireShared(int arg) {
// 尝试去获取共享锁，如果返回值小于0表示获取共享锁失败
if (tryAcquireShared(arg) < 0)
// 调用doAcquireShared方法去获取共享锁
doAcquireShared(arg);
}
方法分析：
- tryAcquireShared方法：尝试去获取共享锁，返回值小于0表示获取共享锁失败，就要调用doAcquireShared方法。返回值大于等于0,获取成功，直接返回。这个方法由子类实现。
- doAcquireShared方法: 获取共享锁。如果获取失败，当前线程就会处于WAITING等待状态。如果获取成功，因为是共享锁，所以当前线程也会去唤醒一个等待线程。
1.2 releaseShared 释放共享锁的方法
// 释放共享锁
public final boolean releaseShared(int arg) {
// 尝试释放共享锁
if (tryReleaseShared(arg)) {
// 唤醒等待共享锁的线程
doReleaseShared();
return true;
}
return false;
}
方法分析：
- tryReleaseShared方法，尝试去释放共享锁资源。如果返回true，表示该共享锁可以被获取了，那么就要调用doReleaseShared方法，去唤醒所有等待共享锁的线程。如果返回false，则什么都不做。
- doReleaseShared方法，唤醒所有等待共享锁的线程。
1.3 小结
所以要实现一个共享锁，我们只要继承AQS类，并实现tryAcquireShared和tryReleaseShared方法就行了。
二. Semaphore类
假如有这样一个需求，现在有许多线程要执行，我们要控制同时执行的线程数量，当达到这个数量时，其他线程必须等待，只有当有线程执行完毕时，才会唤醒等待线程，让它执行。
形象地解释就是，有5个厕所，但是有10个人准备上厕所。所以只有前面5个人才能上厕所，后面的人必须等待。
2.1 Semaphore类介绍
在java中用Semaphore类就可以很方便地实现这个功能，Semaphore类是一个共享锁，所以允许多个线程获取共享锁，它有一个permits许可数变量，只有当permits许可数大于0时，线程才可以获取共享锁，否则线程就要阻塞等待。
2.2 重要属性和方法
/** AQS的子类，使用实现共享锁 */
private final Sync sync;
// 获取共享锁，如果获取不到，就一直等待。不响应中断请求
public void acquireUninterruptibly() {
sync.acquireShared(1);
}
// 释放共享锁，当前线程添加一个许可，唤醒等待许可的线程
public void release() {
sync.releaseShared(1);
}
可以看出Semaphore类获取锁以及释放锁的方法，都是通过sync的方法实现的。Sync是AQS的子类，实现了tryAcquireShared和tryReleaseShared方法。
2.3 Sync内部类
/**
* 非公平方式获取 Semaphore共享锁
* 每当获取Semaphore共享锁，都会消耗一定数量的许可，也就是会减少state的值。
* 当state减去要获取的许可数的剩余值小于0时，表示不能提供想要的许可数，
* 获取共享锁失败，当前线程必须等待。
*/
final int nonfairTryAcquireShared(int acquires) {
// 采用CAS方式的乐观锁，来实现修改state状态时的多线程安全，没有阻塞线程
for (;;) {
// 得到当前的许可数
int available = getState();
// 计算减去想要获取许可数acquires之后的剩余值remaining
int remaining = available - acquires;
// 1. 如果remaining小于0，表示不能提供想要的许可数，获取共享锁失败，返回remaining值
// 2. 如果remaining大于等于0，则调用compareAndSetState方法。
// 如果CAS调用失败，表示有别的线程修改了锁的状态state，那么就循环重试，
// 如果成功表示获取共享锁成功，返回remaining值(肯定大于等于0)
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
/**
* 尝试去释放共享锁。返回true表示释放共享锁成功
* 每次释放Semaphore共享锁，都会添加一定数量的许可，也就是会增加state的值。
* (所以Semaphore拥有的许可总数是可以比初始传递的许可数要多的。)
* 而且只要修改state状态成功，就表示添加了一些许可，这个时候就要唤醒那些等待许可被阻塞的线程。
*/
protected final boolean tryReleaseShared(int releases) {
// 采用CAS方式的乐观锁，来实现修改state状态时的多线程安全，没有阻塞线程
for (;;) {
// 得到当前的许可数
int current = getState();
// 计算新的许可数next
int next = current + releases;
// 表示许可数超出了int类型的上限，抛出Error
if (next < current)
throw new Error("Maximum permit count exceeded");
// CAS返回false表示别的线程修改了锁的state值，那么循环重试
// 返回true表示添加了新的许可，就要唤醒那些等待许可被阻塞的线程。
if (compareAndSetState(current, next))
return true;
}
}
Sync类实现了非公平方法获取锁的方法，以及释放锁的方法。
通过tryReleaseShared方法，我们发现permits许可数是允许超过初始化中赋予的值。也就是说厕所是有可能变多的。
2.4 NonfairSync 和 FairSync内部类
/**
* 非公平锁
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = -2694183684443567898L;
// 初始化拥有的许可数
NonfairSync(int permits) {
super(permits);
}
// 非公平方式获取共享锁
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
}
/**
* 公平锁
*/
static final class FairSync extends Sync {
private static final long serialVersionUID = 2014338818796000944L;
// 初始化拥有的许可数
FairSync(int permits) {
super(permits);
}
/**
*
* @param acquires
*/
protected int tryAcquireShared(int acquires) {
// 采用CAS方式的乐观锁，来实现修改state状态时的多线程安全，没有阻塞线程
for (;;) {
// hasQueuedPredecessors返回true，表示在等待锁的线程池中，有别的线程在当前线程之前，
// 根据公平锁的原则，当前线程不能获取锁。
if (hasQueuedPredecessors())
return -1;
// 得到当前的许可数
int available = getState();
// 计算减去想要获取许可数acquires之后的剩余值remaining
int remaining = available - acquires;
// 1. 如果remaining小于0，表示不能提供想要的许可数，获取共享锁失败，返回remaining值
// 2. 如果remaining大于等于0，则调用compareAndSetState方法。
// 如果CAS调用失败，表示有别的线程修改了锁的状态state，那么就循环重试，
// 如果成功表示获取共享锁成功，返回remaining值(肯定大于等于0)
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
公平锁和非公平锁最大的区别就是，获取锁的时候，是否要判断当前线程是不是等待线程队列中的第一个。
2.5 Semaphore类使用示例
import java.util.concurrent.Semaphore;
public class CountDownLatchTest1 {
public static void newThread(Semaphore semaphore, String name, int time) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+" 开始");
try {
semaphore.acquire();
System.out.println("线程"+Thread.currentThread().getName()+" 获取了许可");
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
semaphore.release();
System.out.println("线程"+Thread.currentThread().getName()+" 结束");
}
}, name);
t.start();
}
public static void main(String[] args) throws InterruptedException {
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <= 6; i++) {
newThread(semaphore,"t"+i, 100);
}
}
}
执行结果:
线程t1 开始
线程t1 获取了许可
线程t2 开始
线程t2 获取了许可
线程t3 开始
线程t3 获取了许可
线程t4 开始
线程t5 开始
线程t6 开始
线程t1 结束
线程t4 获取了许可
线程t2 结束
线程t6 获取了许可
线程t3 结束
线程t5 获取了许可
线程t4 结束
线程t5 结束
线程t6 结束
三. CountDownLatch
我们经常碰到这样一个需求，想让当前线程等待另一个线程完成之后在操作，这个很简单，在当前线程中调用另一个线程的join方法。
但是如果是想让当前线程等待多个线程完成之后在操作，那么怎么办呢？
有人说这个也简单，在当前线程中分别调用线程的join方法，这样做是可以的，但是显得繁琐。
那么如果让多个线程等待多个线程完成之后在操作，该怎么办呢？在使用join方法就有点不切实际了。而这些需求都可以使用CountDownLatch类来实现。
3.1 CountDownLatch类介绍
CountDownLatch类也是一个共享锁，它有个变量count，当获取共享锁时，只有count等于0，才能获取成功，否则都是获取失败，当前线程阻塞等待。
而变量count是通过CountDownLatch类的countDown方法来减少的，当count减少到0时，相当于释放共享锁，要唤醒所有等待阻塞的线程。
3.2 CountDownLatch类重要属性和方法
/** AQS的子类，使用实现共享锁 */
private final Sync sync;
// 获取锁，如果获取不到，就一直等待。如果有中断请求就抛出异常
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
// 尝试释放共享锁， 将count值减一
public void countDown() {
sync.releaseShared(1);
}
可以看出CountDownLatch类获取锁以及释放锁的方法，也都是通过sync的方法实现的。Sync是AQS的子类，实现了tryAcquireShared和tryReleaseShared方法。
3.3 Sync内部类
/**
* 尝试获取共享锁。根据共享锁的规则，当返回值小于0表示获取失败，当前线程需要等待。
* 我们发现当前只有当state值等于0的时候，才能获取共享锁。
* 而state值在两个地方发生改变，1. Sync(int count)初始化的时候
* 2. tryReleaseShared尝试释放共享锁的时候。
* 注意：tryAcquireShared方法并没有改变state的值。
*/
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
/**
* 尝试去释放CountDownLatch共享锁，返回true，表示释放成功。
* 当state大于0时，每次调用tryReleaseShared方法，都会将state数量减一。
* 只有当state等于0的时候，返回true，成功释放锁，就会唤醒等待锁的线程。
*/
protected boolean tryReleaseShared(int releases) {
// 采用CAS方式的乐观锁，来实现修改state状态时的多线程安全，没有阻塞线程
for (;;) {
//
int c = getState();
//等于0，说明共享锁已经被释放，唤醒等待锁的线程操作也已经发出，所以这个返回false。
if (c == 0)
return false;
// 将state数量减一。
int nextc = c-1;
// 返回false，表示state被别的线程更改了，所以循环重试。
if (compareAndSetState(c, nextc))
// 等于0，表示完全释放CountDownLatch共享锁了。
return nextc == 0;
}
}
注意：CountDownLatch类中Sync没有公平锁和非公平锁的子类，因为对于CountDownLatch类共享锁来说，获取锁的成功条件只有一个就是count等于0.
3.4 CountDownLatch的使用示例
import java.util.concurrent.CountDownLatch;
public class CountDownLatchTest {
public static void newThread(CountDownLatch latch, String name, int time) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+" 开始");
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 尝试释放CountDownLatch锁
latch.countDown();
System.out.println("线程"+Thread.currentThread().getName()+" 结束");
}
}, name);
t.start();
}
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(4);
newThread(latch,"t1", 10);
newThread(latch,"t2", 100);
newThread(latch,"t3", 200);
newThread(latch,"t4", 500);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+" 开始");
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程"+Thread.currentThread().getName()+" 结束");
}
}, "thread000000000").start();
latch.await();
System.out.println("主线程结束");
}
}
执行结果：
线程t1 开始
线程t2 开始
线程t3 开始
线程t4 开始
线程thread000000000 开始
线程t1 结束
线程t2 结束
线程t3 结束
线程t4 结束
主线程结束
线程thread000000000 结束
主线程和thread000000000线程都会等待t1、t2、t3、t4线程都执行完毕之后，才继续执行。
