都说AQS不好理解，那我们今天就来进个阶儿，好好说到说到

大家好，我是方圆
让我们一起学好多线程啊！

1. AQS在CountDownLatch中的应用

1.1 其中的AQS静态内部类

在这里插入图片描述

protected的访问范围：基类中的protected成员是包内可见的，并且对子类可见；若子类与基类不在用一个包，那么子类可以访问从基类中继承来的protected方法，而不能访问基类的protected方法

1.2 构造方法

在这里插入图片描述

1.3 getCount()方法

在这里插入图片描述

1.4 CountDown()方法

在这里插入图片描述
然而这个releaseShared方法，Sync并没有重写它，而是调用其父类AbstractQueueSynchronizer中的方法

1.5 await()方法

在这里插入图片描述

执行该方法的目的就是进行线程阻塞

其中阻塞队列如下图，将Node压入队列，将其阻塞，其中parkAndCheckInterrupt()方法便是实现的阻塞

再往下呢

1.6 总结

调用CountDownLatch的await方法时，便会尝试获取“共享锁”，不过一开始是获取不到的，于是线程被阻塞
而“共享锁的获取条件”是，计数器的值为0
计数器的初始值为，我们设置的，也就是对应其中的state值，只有执行countDown()方法时，才能将锁计数器减1
直到state个线程执行countDown()之后，将其减为0，前面提到的等待获取共享锁的线程才能继续运行

2. AQS在Semaphore中的应用

2.1 acquire()方法

在这里插入图片描述

2.2 release()方法

在这里插入图片描述

扫描二维码关注公众号，回复： 11824620 查看本文章

2.3 总结

在Semaphore中，state表示许可证的剩余数量
nonfairTryAcquireShared方法返回值大于0，代表获取信号量成功
若返回的是负数，则代表已经没有信号量可以再进行获取了，进行阻塞

3. AQS在ReentrantLock中的应用

3.1 lock()方法

在这里插入图片描述
进入acquire方法，说明该锁已经被获取，那么这个acquire方法中，必定是判断重入与其他线程的阻塞

我们再回头看require方法，第一个条件已经判断完成，如果是前两种情况的话，那么返回true，取非为false，不再向下执行；若为最后一种情况，则执行如下方法
在这里插入图片描述

3.2 unlock()方法

在这里插入图片描述
进入到AQS父类中的release方法

3.3 总结

state代表重入次数，每次释放锁的时候，先判断是不是当前线程释放锁，如果不是，报错；否则重入次数减1，直到为0，就说明完全被释放了，free为true，并把state设置为0

4. 自己实现一个AQS

在这里插入图片描述

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedLongSynchronizer;

//让我们做一个门栓，进来线程都进行等待，由主线程进行放开
public class MyCountDown {
    
    

    private Sync sync = new Sync();

    private static class Sync extends AbstractQueuedLongSynchronizer{
    
    

        @Override
        protected long tryAcquireShared(long arg) {
    
    
            //初始值为0，返回-1，那么将会被阻塞
            return (getState() == 1) ? 1 : -1;
        }

        @Override
        protected boolean tryReleaseShared(long arg) {
    
    
            //只要执行了signal方法，那么就直接将state设置为1
            //开闸放水
            setState(1);

            return true;
        }
    }

    public void signal() {
    
    
        //唤醒线程
        sync.releaseShared(0);
    }

    public void await() {
    
    
        //让线程进行等待
        sync.acquireShared(0);
    }

    public static void main(String[] args) throws InterruptedException {
    
    
        MyCountDown myCountDown = new MyCountDown();

        for (int i = 0; i < 3; i++) {
    
    
            new Thread(() -> {
    
    
                System.out.println(Thread.currentThread().getName() + "进入门内");
                myCountDown.await();
                System.out.println(Thread.currentThread().getName() + "开闸跑了");
            }).start();
        }

        TimeUnit.SECONDS.sleep(3);

        myCountDown.signal();
    }
}