AQS
AQS(AbstractQueuedSynchronizer)
- AQS是一个用于构建锁、同步器、协作工具类的工具类(框架)。有了AQS以后，更多的协作工具类都可以很方便得被写出来
- ReentrantLock,Semaphore,ReentrantLock和Semaphore,包括CountDownLatch、ReentrantReadWriteLock都有这样类似的“协作”(或者叫“同步”)功能，其实，它们底层都用了一个共同的基类这就是AQS
- 有了AQS,构建线程协作类就容易多了。
- Semaphore内部有一个Sync类，Sync类继承了AQS
- CountDownLatch也一样
AQS核心三部分
- state
- 这里的state的具体含义，会根据具体实现类的不同而不同比如在Semaphore里，它表示“剩余的许可证的数量”，而在CountDownLatch里，它表示“还需要倒数的数量”
- ReentrantLock中，state表示”锁”的占有情况，包括可重入计数.值为0的时候，标识改Lock不被任何线程所占有.
- state是volatile修饰的，会被并发地修改，所以所有修改state的方法都需要保证线程安全，比如getState、setState以及compareAndSetState操作来读取和更新这个状态。这些方法都依赖于j.u.C.atomic包的支持
- 控制线程抢锁和配合的FIFO队列
- 这个队列用来存放“等待的线程”,AQS就是“排队管理器”当多个线程争用同一把锁时，必须有排队机制将那些没能拿到锁的线程串在一起。当锁释放时，锁管理器就会挑选-个合适的线程来占有这个刚刚释放的锁
- AQS会维护一个等待的线程队列，把线程都放到这个队列里
- 这是一个双向形式的队列
- 期望协作工具类去实现的获取/释放等重要方法
- 这里的获取和释放方法，是利用AQS的协作工具类里最重要的方法，是由协作类自己去实现的，并且含义各不相同
- 获取方法
- 获取操作会依赖state变量，经常会阻塞(比如获取不到锁的时候)
- 在Semaphore中，获取就是acquire方法，作用是获取·一个许可证
- 而在CountDownLatch里面，获取就是await方法，作用是“等待，直到倒数结束”
- 释放方法
- 释放操作不会阻塞
- 在Semaphore中，释放就是release方法，作用是释放一个许可证
- CountDownLatch里面，获取就是countDown方法，作用是“倒数1个数”
- 需要重写tryAcquire和tryRelease或tryAcquireShared (int acquires)和tryReleaseShared(intreleases)等方法
AQS在CountDownLatch
- 调用CountDownLatch的await方法时，便会尝试获取“共享锁”,不过一开始是获取不到该锁的，于是线程被阻塞。
- 而“共享锁”可获取到的条件，就是“锁计数器”的值为0。
- 而“锁计数器”的初始值为count,每当一个线程调用该CountDownLatch对象的countDown()方法时，才将“锁计数器”-1
- count个线程调用countDown()之后，“锁计数器”才为0,而前面提到的等待获取共享锁的线程才能继续运行。
AQS在Semaphore
- 在Semaphore中，state表示许可证的剩余数量
- 看tryAcquire方法，判断nonfairTryAcquireShared大于等于0的话，代表成功
- 这里会先检查剩余许可证数量够不够这次需要的，用减法来计算，如果直接不够，那就返回负数，表示失败，如果够了，就用自旋加compareAndSetState来改变state状态，直到改变成功就返回正数；或者是期间如果被其他人修改了导致剩余数量不够了，那也返回负数代表获取失败
AQS在ReentrantLock
分析释放锁的方法tryRelease
由于是可重入的，所以state代表重入的次数，每次释放锁先判断是不是当前持有锁的线程释放的，如果不是就抛异常，如果是的话，重入次数就减一，如果减到了0,就说明完全释放了，于是free就是true,并且把state设置为0。
AQS用法
第一步：写一个类，想好协作的逻辑，实现获取/释放方法。
第二步：内部写一个Sync类继承AbstractQueuedSynchronizer
第三步：根据是否独占来重写tryAcquire/tryRelease或tryAcquireShared (int acquires)和tryReleaseShared(intreleases)等方法，在之前写的获取/释放方法中调用AQS的acquire/release或者Shared方法
public class OneShotLatch {
private final Sync sync = new Sync();
public void signal() {
sync.releaseShared(0);
}
public void await() {
sync.acquireShared(0);
}
private class Sync extends AbstractQueuedSynchronizer {
@Override
protected int tryAcquireShared(int arg) {
return (getState() == 1) ? 1 : -1;
}
@Override
protected boolean tryReleaseShared(int arg) {
setState(1);
return true;
}
}
public static void main(String[] args) throws InterruptedException {
OneShotLatch oneShotLatch = new OneShotLatch();
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"尝试获取latch，获取失败那就等待");
oneShotLatch.await();
System.out.println("开闸放行"+Thread.currentThread().getName()+"继续运行");
}
}).start();
}
Thread.sleep(5000);
oneShotLatch.signal();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"尝试获取latch，获取失败那就等待");
oneShotLatch.await();
System.out.println("开闸放行"+Thread.currentThread().getName()+"继续运行");
}
}).start();
}
}
