AQS抽象队列同步详解、信号量、倒计数器、栅栏

同步锁本质

同步的方式：独享锁 - 单个队列窗口，共享锁 - 多个队列窗口

抢锁的方式：插队抢（不公平锁）、先来后到的抢锁（公平锁）

没抢到锁的方式：快速尝试多次（CAS自选锁）、阻塞等待

唤醒阻塞线程的方式（叫号器）：全部通知、通知下一个

//自己实现（独享锁）
public class DevonLock implements Lock {

    //1.判断一个锁的状态或者说 拥有者
    volatile AtomicReference<Thread> owner = new AtomicReference<>();

    //保存正在等待的线程
    volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();

    @Override
    public void lock() {
        boolean addQ = true;
        while(!tryLock()){
            if(addQ){
                //没有拿到锁，等待，加入等待集合
                waiters.offer(Thread.currentThread());
                addQ = false;
            }else{
                //阻塞 挂起挡墙线程，不要据需往下执行
                LockSupport.park();//伪唤醒，非unpark调用唤醒
            }
        }
        waiters.remove(Thread.currentThread());
    }

    @Override
    public void unlock() {
        //释放拥有者
        if (owner.compareAndSet(Thread.currentThread(),null)) {//释放成功
            //通知等待着
            Iterator<Thread> iterator = waiters.iterator();
            while(iterator.hasNext()){
                Thread next = iterator.next();
                LockSupport.unpark(next);//唤醒等待的线程
            }
        }
    }

    //尝试去获取一次锁
    @Override
    public boolean tryLock() {
        return owner.compareAndSet(null,Thread.currentThread());
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

public class LockDemo3 {
    volatile int i = 0;

    Lock lock = new DevonLock();

    public void add() {
        lock.lock();
        try {
            // TODO  很多业务操作
            i++;
        }finally {
            lock.unlock();
        }
    }

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

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    ld.add();
                }
            }).start();
        }
        Thread.sleep(2000L);
        System.out.println(ld.i);
    }
}

 AQS抽象队列同步器

提供了对资源占用、释放，线程的等待、唤醒等等接口和具体实现，即，将线程释放，等待等线程方法抽象出来封装

方法定义：

 acquire、 acquireShared ： 定义了资源争用的逻辑，如果没拿到，则等待。
 tryAcquire、 tryAcquireShared ： 实际执行占用资源的操作，如何判定一个由使用者具体去实现。
 release、 releaseShared ： 定义释放资源的逻辑，释放之后，通知后续节点进行争抢。
 tryRelease、 tryReleaseShared： 实际执行资源释放的操作，具体的AQS使用者去实现。

自己实现独享锁

public class DevonAqs {
    // acquire、 acquireShared ： 定义了资源争用的逻辑，如果没拿到，则等待。
    // tryAcquire、 tryAcquireShared ： 实际执行占用资源的操作，如何判定一个由使用者具体去实现。
    // release、 releaseShared ： 定义释放资源的逻辑，释放之后，通知后续节点进行争抢。
    // tryRelease、 tryReleaseShared： 实际执行资源释放的操作，具体的AQS使用者去实现。

    // 1、 如何判断一个资源的拥有者
    public volatile AtomicReference<Thread> owner = new AtomicReference<>();
    // 保存 正在等待的线程
    public volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();


    public boolean tryAcquire() {
        throw new UnsupportedOperationException();
    }

    //定义了资源争用的逻辑 即等待逻辑
    public void acquire(){
        boolean addQ = true;
        while(!tryAcquire()){
            if(addQ){
                //没有拿到锁，等待，加入等待集合
                waiters.offer(Thread.currentThread());
                addQ = false;
            }else{
                //阻塞 挂起挡墙线程，不要据需往下执行
                LockSupport.park();//伪唤醒，非unpark调用唤醒
            }
        }
        waiters.remove(Thread.currentThread());
    }

    public boolean tryRelease() {
        throw new UnsupportedOperationException();
    }

    public void release(){//定义了释放资源之后的操作
        if (!tryRelease()){
            //通知等待着
            Iterator<Thread> iterator = waiters.iterator();
            while(iterator.hasNext()){
                Thread next = iterator.next();
                LockSupport.unpark(next);//唤醒等待的线程
            }
        }
    }


}

//自己实现（独享锁）
public class DevonLock implements Lock {

    DevonAqs aqs = new DevonAqs(){
        @Override
        public boolean tryAcquire() {
            return owner.compareAndSet(null,Thread.currentThread());
        }

        @Override
        public boolean tryRelease() {
            return owner.compareAndSet(Thread.currentThread(),null);
        }
    };

    //尝试去获取一次锁
    @Override
    public boolean tryLock() {
        return aqs.tryAcquire();
    };


    @Override
    public void lock() {
        aqs.acquire();
    }

    @Override
    public void unlock() {
        aqs.release();
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

public class LockDemo3 {
    volatile int i = 0;

    Lock lock = new DevonLock();

    public void add() {
        lock.lock();
        try {
            // TODO  很多业务操作
            i++;
        }finally {
            lock.unlock();
        }
    }

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

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    ld.add();
                }
            }).start();
        }
        Thread.sleep(2000L);
        System.out.println(ld.i);
    }
}

Semaphore

信号量，控制多个线程争抢许可。

acquire：获取一个许可，如果没有就等待

release：释放一个许可。

availablePermites：方法得到可用的许可项目

// 信号量机制
public class SemaphoreDemo {
    public static void main(String[] args) {
        SemaphoreDemo semaphoreTest = new SemaphoreDemo();
        int N = 9;            // 客人数量
        Semaphore semaphore = new Semaphore(5); // 手牌数量，限制请求数量
        for (int i = 0; i < N; i++) {
            String vipNo = "vip-00" + i;
            new Thread(() -> {
                try {
                    semaphore.acquire(); // 获取令牌

                    semaphoreTest.service(vipNo);

                    semaphore.release(); // 释放令牌
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

    // 限流 控制5个线程 同时访问
    public void service(String vipNo) throws InterruptedException {
        System.out.println("楼上出来迎接贵宾一位，贵宾编号" + vipNo + "，...");
        Thread.sleep(new Random().nextInt(3000));
        System.out.println("欢送贵宾出门，贵宾编号" + vipNo);
    }

}

自己实现信号量

public class DevonAqs {
    // acquire、 acquireShared ： 定义了资源争用的逻辑，如果没拿到，则等待。
    // tryAcquire、 tryAcquireShared ： 实际执行占用资源的操作，如何判定一个由使用者具体去实现。
    // release、 releaseShared ： 定义释放资源的逻辑，释放之后，通知后续节点进行争抢。
    // tryRelease、 tryReleaseShared： 实际执行资源释放的操作，具体的AQS使用者去实现。

    // 1、 如何判断一个资源的拥有者
    public volatile AtomicReference<Thread> owner = new AtomicReference<>();
    // 保存 正在等待的线程
    public volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();
    //记录资源状态
    public volatile AtomicInteger state = new AtomicInteger(0);



    //共享资源占用的逻辑，返回资源占用的逻辑
    public int tryAcquireShared(){
        throw new UnsupportedOperationException();
    }

    public void acquireShared(){
        boolean addQ = true;
        while (tryAcquireShared()<0){
            if(addQ){
                //没有拿到锁，等待，加入等待集合
                waiters.offer(Thread.currentThread());
                addQ = false;
            }else{
                //阻塞 挂起挡墙线程，不要据需往下执行
                LockSupport.park();//伪唤醒，非unpark调用唤醒
            }
        }
        waiters.remove(Thread.currentThread());
    }

    public void releaseShared(){
        if (tryReleaseShared()){
            //通知等待着
            Iterator<Thread> iterator = waiters.iterator();
            while (iterator.hasNext()) {
                Thread next = iterator.next();
                LockSupport.unpark(next); // 唤醒
            }
        }
    }

    public boolean tryReleaseShared() {
        throw new UnsupportedOperationException();
    }


    public AtomicInteger getState() {
        return state;
    }

    public void setState(AtomicInteger state) {
        this.state = state;
    }

    //独占资源的逻辑


    public boolean tryAcquire() {
        throw new UnsupportedOperationException();
    }
    //定义了资源争用的逻辑 即等待逻辑

    public void acquire(){
        boolean addQ = true;
        while(!tryAcquire()){
            if(addQ){
                //没有拿到锁，等待，加入等待集合
                waiters.offer(Thread.currentThread());
                addQ = false;
            }else{
                //阻塞 挂起挡墙线程，不要据需往下执行
                LockSupport.park();//伪唤醒，非unpark调用唤醒
            }
        }
        waiters.remove(Thread.currentThread());
    }

    public boolean tryRelease() {
        throw new UnsupportedOperationException();
    }

    public void release(){//定义了释放资源之后的操作
        if (!tryRelease()){
            //通知等待着
            Iterator<Thread> iterator = waiters.iterator();
            while(iterator.hasNext()){
                Thread next = iterator.next();
                LockSupport.unpark(next);//唤醒等待的线程
            }
        }
    }

}

public class DevonSemaphore {

    DevonAqs aqs = new DevonAqs(){
        @Override
        public int tryAcquireShared() {//请求之后令牌数减一 state - 1
            for (;;){
                int count = getState().get(); //为了避免减成负数
                int n = count -1;
                if (count <=0 || n <0){
                    return -1;
                }

                if (getState().compareAndSet(count,n)){
                    return 1;
                }
            }

        }

        @Override
        public boolean tryReleaseShared() {//释放之后令牌数加一 state +1
            return getState().incrementAndGet() >= 0;
        }
    };

    public DevonSemaphore(int count){
        aqs.getState().set(count);
    }

    public void acquire(){//获得令牌
        aqs.acquireShared();
    }

    public void release(){//释放令牌
        aqs.releaseShared();
    }
}

// 信号量机制
public class SemaphoreDemo {
    public static void main(String[] args) {
        SemaphoreDemo semaphoreTest = new SemaphoreDemo();
        int N = 9;            // 客人数量
        DevonSemaphore semaphore = new DevonSemaphore(5); // 手牌数量，限制请求数量
        for (int i = 0; i < N; i++) {
            String vipNo = "vip-00" + i;
            new Thread(() -> {
                try {
                    semaphore.acquire(); // 获取令牌

                    semaphoreTest.service(vipNo);

                    semaphore.release(); // 释放令牌

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

    // 限流 控制5个线程 同时访问
    public void service(String vipNo) throws InterruptedException {
        System.out.println("楼上出来迎接贵宾一位，贵宾编号" + vipNo + "，...");
        Thread.sleep(new Random().nextInt(3000));
        System.out.println("欢送贵宾出门，贵宾编号" + vipNo);
    }

}
/*
楼上出来迎接贵宾一位，贵宾编号vip-000，...
楼上出来迎接贵宾一位，贵宾编号vip-001，...
楼上出来迎接贵宾一位，贵宾编号vip-002，...
楼上出来迎接贵宾一位，贵宾编号vip-003，...
楼上出来迎接贵宾一位，贵宾编号vip-004，...
欢送贵宾出门，贵宾编号vip-003
楼上出来迎接贵宾一位，贵宾编号vip-006，...
欢送贵宾出门，贵宾编号vip-001
楼上出来迎接贵宾一位，贵宾编号vip-005，...
欢送贵宾出门，贵宾编号vip-004
楼上出来迎接贵宾一位，贵宾编号vip-007，...
欢送贵宾出门，贵宾编号vip-000
楼上出来迎接贵宾一位，贵宾编号vip-008，...
欢送贵宾出门，贵宾编号vip-002
欢送贵宾出门，贵宾编号vip-007
欢送贵宾出门，贵宾编号vip-008
欢送贵宾出门，贵宾编号vip-006
欢送贵宾出门，贵宾编号vip-005
 */

CountDownLatch（倒计数器）

创建对象时，传入指定数值作为线程参与的数量；

await：方法等待计数器变为0，在这之前，线程 进入等待状态；

countdown：计数器数值减一，直到为0；

经常用于等待其他线程执行到某一节点，在继续执行当前线程代码。

使用场景：

1、统计线程执行的状况

2、压力测试，实现最大程度的并发处理

3、多个线程之间，相互通信，比如线程异步调用完接口，结果通知

// CountDownLatch 自己实现
public class CDLdemo {
    DevonAqs aqSdemo = new DevonAqs() {
        @Override
        public int tryAcquireShared() { // 如果非等于0，代表当前还有线程没准备就绪，则认为需要等待
            return this.getState().get() == 0 ? 1 : -1;
        }

        @Override
        public boolean tryReleaseShared() { // 如果非等于0，代表当前还有线程没准备就绪，则不会通知继续执行
            return this.getState().decrementAndGet() == 0;
        }
    };

    public CDLdemo(int count) {
        aqSdemo.setState(new AtomicInteger(count));
    }

    public void await() {
        aqSdemo.acquireShared();
    }

    public void countDown() {
        aqSdemo.releaseShared();
    }


    public static void main(String[] args) throws InterruptedException {
        // 一个请求，后台需要调用多个接口 查询数据
        CDLdemo cdLdemo = new CDLdemo(10); // 创建，计数数值
        for (int i = 0; i < 10; i++) { // 启动九个线程，最后一个两秒后启动
            int finalI = i;
            new Thread(() -> {
                try {
                    Thread.sleep(2000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是" + Thread.currentThread() + ".我执行接口-" + finalI +"调用了");
                cdLdemo.countDown(); // 参与计数
                // 不影响后续操作
            }).start();
        }

        cdLdemo.await(); // 等待计数器为0
        System.out.println("全部执行完毕.我来召唤神龙");

    }
}
/*
我是Thread[Thread-0,5,main].我执行接口-0调用了
我是Thread[Thread-1,5,main].我执行接口-1调用了
我是Thread[Thread-2,5,main].我执行接口-2调用了
我是Thread[Thread-3,5,main].我执行接口-3调用了
我是Thread[Thread-4,5,main].我执行接口-4调用了
我是Thread[Thread-5,5,main].我执行接口-5调用了
我是Thread[Thread-6,5,main].我执行接口-6调用了
我是Thread[Thread-7,5,main].我执行接口-7调用了
我是Thread[Thread-8,5,main].我执行接口-8调用了
我是Thread[Thread-9,5,main].我执行接口-9调用了
全部执行完毕.我来召唤神龙
 */

CyclicBarrier（线程栅栏）

创建对象时，指定栅栏线程数量。

await：等待数量的线程都处于等待状态时，继续执行后续代码。

barrierAction：线程数量到了指定量之后，自动触发执行任务。

和CountDownLatch的区别是，CyclicBarrier对象可多次触发执行。

// 循环屏障(栅栏)，示例：数据库批量插入
public class CyclicBarrierTest {
    public static void main(String[] args) throws InterruptedException {
        LinkedBlockingQueue<String> sqls = new LinkedBlockingQueue<>();
        // 任务1+2+3...1000  拆分为100个任务（1+..10,  11+20） -> 100线程去处理。

        // 每当有4个线程处于await状态的时候，则会触发barrierAction执行
        CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() {
            @Override
            public void run() {
                // 这是每满足4次数据库操作，就触发一次批量执行
                System.out.println("有4个线程执行了，开始批量插入： " + Thread.currentThread());
                for (int i = 0; i < 4; i++) {
                    System.out.println(sqls.poll());
                }
            }
        });

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    sqls.add("data - " + Thread.currentThread()); // 缓存起来
                    Thread.sleep(1000L); // 模拟数据库操作耗时
                    barrier.await(); // 等待栅栏打开,有4个线程都执行到这段代码的时候，才会继续往下执行
                    System.out.println(Thread.currentThread() + "插入完毕");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }

        Thread.sleep(2000);
    }
}
/*
有4个线程执行了，开始批量插入： Thread[Thread-4,5,main]
data - Thread[Thread-0,5,main]
data - Thread[Thread-1,5,main]
data - Thread[Thread-2,5,main]
data - Thread[Thread-3,5,main]
Thread[Thread-4,5,main]插入完毕
Thread[Thread-2,5,main]插入完毕
Thread[Thread-3,5,main]插入完毕
Thread[Thread-0,5,main]插入完毕
有4个线程执行了，开始批量插入： Thread[Thread-7,5,main]
data - Thread[Thread-4,5,main]
data - Thread[Thread-5,5,main]
data - Thread[Thread-6,5,main]
data - Thread[Thread-7,5,main]
Thread[Thread-7,5,main]插入完毕
Thread[Thread-6,5,main]插入完毕
Thread[Thread-5,5,main]插入完毕
Thread[Thread-1,5,main]插入完毕
 */

　　

以上部分内容代码摘自网易云课堂