快速了解基于AQS实现的Java并发工具类

@Slf4j
public class CountDownLatchExample {

    private final static int threadCount = 200;

    public static void main(String[] args) throws Exception {

        ExecutorService exec = Executors.newCachedThreadPool();
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
//        Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
//                    semaphore.acquire(); // 获取一个许可
                    test(threadNum);
//                    semaphore.release(); // 释放一个许可
                } catch (Exception e) {
                    log.error("exception", e);
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        countDownLatch.await(10, TimeUnit.MILLISECONDS);
        log.info("finish");
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        Thread.sleep(100);
        log.info("{}", threadNum);
    }
}

@Slf4j
public class CyclicBarrierExample {

    private static CyclicBarrier barrier = new CyclicBarrier(5, () -> {
        log.info("callback is running"); // await触发后，先执行这个回调函数，例如这里可以做数据汇总
    });

    public static void main(String[] args) throws Exception {

        ExecutorService executor = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            final int threadNum = i;
            Thread.sleep(1000);
            executor.execute(() -> {
                try {
                    race(threadNum);
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        executor.shutdown();
    }

    private static void race(int threadNum) throws Exception {
        Thread.sleep(1000);
        log.info("{} is ready", threadNum);
        // 例如这里可以做数据计算
        barrier.await();
        log.info("{} continue", threadNum);
    }
}

class Solution {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        AtomicInteger count = new AtomicInteger(1);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(6,()->{
            System.out.println(String.format("同学们到齐了+%d", count.getAndIncrement()));
        });
//        CyclicBarrier cyclicBarrier = new CyclicBarrier(6);
        for (int i = 1; i <= 18; i++) {
            executorService.execute(()-> {
                System.out.println(Thread.currentThread().getName() + "开始等待其他线程");
                    try {
                        cyclicBarrier.await();
                        System.out.println(Thread.currentThread().getName() + "开始执行业务逻辑，耗时0.5秒");
                        // 工作线程开始处理，这里用Thread.sleep()来模拟业务处理
                        Thread.sleep(500);
                        System.out.println(Thread.currentThread().getName() + "业务逻辑执行完毕");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                });
        }
        executorService.shutdown();
    }
}

class Point {
        private double x, y;
        private final StampedLock sl = new StampedLock();

        // 排他写锁案例
        void move(double deltaX, double deltaY) { // an exclusively locked method
            long stamp = sl.writeLock();
            try {
                x += deltaX;
                y += deltaY;
            } finally {
                sl.unlockWrite(stamp);
            }
        }

        // 乐观读锁案例
        double distanceFromOrigin() { // A read-only method
            long stamp = sl.tryOptimisticRead(); // 获得一个乐观读锁
            double currentX = x, currentY = y;  // 将两个字段读入本地局部变量
            if (!sl.validate(stamp)) { //检查发出乐观读锁后同时是否有其他写锁发生？
                stamp = sl.readLock();  // 如果没有，我们再次获得一个读悲观锁
                try {
                    currentX = x; // 将两个字段读入本地局部变量
                    currentY = y; // 将两个字段读入本地局部变量
                } finally {
                    sl.unlockRead(stamp);
                }
            }
            return Math.sqrt(currentX * currentX + currentY * currentY);
        }

        // 悲观读锁案例
        void moveIfAtOrigin(double newX, double newY) { // upgrade
            // Could instead start with optimistic, not read mode
            long stamp = sl.readLock();
            try {
                while (x == 0.0 && y == 0.0) { // 循环，检查当前状态是否符合
                    long ws = sl.tryConvertToWriteLock(stamp); //将读锁转为写锁
                    if (ws != 0L) { // 这是确认转为写锁是否成功
                        stamp = ws; // 如果成功 替换票据
                        x = newX; // 进行状态改变
                        y = newY;  // 进行状态改变
                        break;
                    } else { // 如果不能成功转换为写锁
                        sl.unlockRead(stamp);  // 我们显式释放读锁
                        stamp = sl.writeLock();  // 显式直接进行写锁 然后再通过循环再试
                    }
                }
            } finally {
                sl.unlock(stamp); // 释放读锁或写锁
            }
        }
    }