基于AQS自定义同步器

最近 复习Java并发编程核心知识点，重温了AQS。有了新的认识,换句话说，之前的学习只是为了面试吹牛，现在学习是为了自己质的提升。
什么是AQS？什么是AQS? 如果你问我什么是AQS,我就带你看这篇我之前写的文章.
Java并发之AQS学习笔记
接下来，笔者将基于AQS自定义一个同步器的行文思路来展开篇幅。鉴于目前广州疫情严峻，以核酸大规模筛查为背景例子演示自定义同步器。

创建核酸筛查服务类
创建sync内部类，继承AQS,重写两组方法：分别是独占式的获取与释放（tryAcquire、tryRelease）与共享式的获取与释放（tryAcquireShared、tryReleaseShared）

public class ScreeningService {

    private sync sync = new sync();


    public ScreeningService() {
    }

    public ScreeningService(int channel) {
        this.sync = new sync(channel);
    }

    /**
     * 排队进入检测点大门
     */
    public void lineUp() {
        sync.acquire(1);
    }

    /**
     * 排队结束 进入检测点大营
     */
    public void pass() {
        sync.release(1);
    }

    /**
     * 筛查结束，有序离场
     */
    public void screeningEnd() {
        sync.releaseShared(1);
    }

    /**
     * 在大营里  筛查排队
     */
    public void lineUp1() {
        sync.acquireShared(1);
    }

    private static class sync extends AbstractQueuedSynchronizer {

        private final Thread NON_THREAD = null;

        sync(int n) {
            setState(n);
        }

        public sync() {
        }

        @Override
        protected int tryAcquireShared(int arg) {
            // 自旋
            for (; ; ) {
                int current = getState();
                // 剩余资源
                int newState = current - arg;
                if (newState < 0 || compareAndSetState(current, newState)) {
                    return newState;
                }
            }
        }

        @Override
        protected boolean tryReleaseShared(int arg) {
            // 自旋
            for (; ; ) {
                int current = getState();
                // 剩余资源
                int newState = current + arg;
                if (compareAndSetState(current, newState)) {
                    return true;
                }
            }
        }

        @Override
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }


        @Override
        protected boolean tryRelease(int arg) {
            if (getState() == 0 || getState() < arg) {
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(NON_THREAD);
            setState(0);
            return true;
        }
    }
}

独占式
我们去做核酸检测，首先要在检测点大营的唯一大门口有序排队并测量体温，一次只能测一个人，进一个人。
我们模拟四个人在大门口进行排队并测量体温，根据上述规则，结果应该是有序打印。

@Test
    public void sync() throws InterruptedException {
        // 独占式
        ScreeningService service = new ScreeningService();
        ExecutorService pool = Executors.newFixedThreadPool(6);
        pool.execute(() -> {
            // 大门口有序排队
            service.lineUp();
            log.info("杨智杰 测量体温并排队中.....");
            try {
                // 模拟排队耗时
                Thread.sleep(1000);
            } catch (InterruptedException ignored) {

            }
            log.info("杨智杰 排队结束 开始进入筛查大营");
            service.pass();
        });
        pool.execute(() -> {
            // 大门口有序排队
            service.lineUp();
            log.info("王晓纯 测量体温并排队中.....");
            try {
                // 模拟排队耗时
                Thread.sleep(1000);
            } catch (InterruptedException ignored) {

            }
            log.info("王晓纯 排队结束 开始进入筛查大营");
            service.pass();
        });
        pool.execute(() -> {
            // 大门口有序排队
            service.lineUp();
            log.info("长安 测量体温并排队中.....");
            try {
                // 模拟排队耗时
                Thread.sleep(1000);
            } catch (InterruptedException ignored) {

            }
            log.info("长安 排队结束 开始进入筛查大营");
            service.pass();
        });
        pool.execute(() -> {
            // 大门口有序排队
            service.lineUp();
            log.info("故里 测量体温并排队中.....");
            try {
                // 模拟排队耗时
                Thread.sleep(1000);
            } catch (InterruptedException ignored) {

            }
            log.info("故里 排队结束 开始进入筛查大营");
            service.pass();
        });

        Thread.sleep(60000);
        pool.shutdown();
    }

测试结果

共享式
进入检测大营后，由于有多条通道可以进行核酸检测，但是每条通道都要各自排队。我们模拟有三个通道，有四个人要进行核酸检测。意味着有一个人要排队，要等其他任意一个通道的人检测完后，第四个人就可以马上过去检测。

 @Test
    public void syncShard() throws InterruptedException {
        // 三个核酸筛查通道
        ScreeningService service = new ScreeningService(3);
        ExecutorService pool = Executors.newFixedThreadPool(6);
        pool.execute(() -> {
            // 通道前有序排队
            service.lineUp1();
            log.info("杨智杰 排队筛查中.....");
            try {
                // 模拟检测
                log.info(" 杨智杰 yue yue yue 差点吐出来....");
                Thread.sleep(3000);

            } catch (InterruptedException ignored) {

            }
            log.info("杨智杰 核酸检测结束 开始有序离开");
            service.screeningEnd();
        });
        pool.execute(() -> {
            // 通道前有序排队
            service.lineUp1();
            log.info("王晓纯 排队筛查中.....");
            try {
                // 模拟排队耗时
                log.info(" 王晓纯 yue yue yue 差点吐出来....");
                Thread.sleep(2000);

            } catch (InterruptedException ignored) {

            }
            log.info("王晓纯 核酸检测结束 开始有序离开");
            service.screeningEnd();
        });
        pool.execute(() -> {
            // 通道前有序排队
            service.lineUp1();
            log.info("长安 排队筛查中.....");
            try {
                // 模拟检测
                log.info(" 长安 yue yue yue 差点吐出来....");
                Thread.sleep(1500);

            } catch (InterruptedException ignored) {

            }
            log.info("长安 核酸检测结束 开始有序离开");
            service.screeningEnd();
        });
        pool.execute(() -> {
            // 通道前有序排队
            service.lineUp1();
            log.info("故里 排队筛查中.....");
            try {
                // 模拟检测
                log.info("故里 yue yue yue 差点吐出来....");
                Thread.sleep(3000);

            } catch (InterruptedException ignored) {

            }
            log.info("故里 核酸检测结束 开始有序离开");
            service.screeningEnd();
        });

        Thread.sleep(15000);
        pool.shutdown();
    }

因为长安检测最快，耗时1.5秒，所以故里可以马上跟长安后面。