并发编程（四）

AQS

一、AQS介绍

AQS：AbstractQueuedSynchronizer，即队列同步器。它是构建锁或者其他同步组件的基础框架（如ReentrantLock、ReentrantReadWriteLock、Semaphore等），JUC并发包的作者（Doug Lea）期望它能够成为实现大部分同步需求的基础。它是JUC并发包中的核心基础组件。

二、AQS组件

需要重点学习的组件有

• CountDownLatch
• Semaphore
• CyclicBarrier
• ReentrantLock

三、CountDownLatch

该类是一个同步辅助类，能够实现让某些线程等待，直到其它线程完成某些操作，线程调用await()方法会使得该线程进入阻塞状态，而其它线程调用countDown()方法会使得计数器减1，直到计数器减到0，被阻塞的线程才会继续执行

该类的使用

@Slf4j
public class CountDownLatchExample1 {

    private final static int threadCount = 200;

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

        ExecutorService exec = Executors.newCachedThreadPool();

        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    test(threadNum);
                } catch (Exception e) {
                    log.error("exception", e);
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        countDownLatch.await();
        log.info("finish");
        exec.shutdown();
    }

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

主线程通过await方法进入阻塞等待，等待countDownLatch到0，主线程继续执行；await方法还可以接受指定等待时间，超过指定时间就不再等待，而是继续执行下去

四、Semaphore

该类可以控制某个资源能够被并发访问的最大线程数量

@Slf4j
public class SemaphoreExample1 {

    private final static int threadCount = 20;

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

        ExecutorService exec = Executors.newCachedThreadPool();
        // 最大并发数为 3
        final Semaphore semaphore = new Semaphore(3);

        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);
                }
            });
        }
        exec.shutdown();
    }

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

@Slf4j
public class SemaphoreExample3 {

    private final static int threadCount = 20;

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

        ExecutorService exec = Executors.newCachedThreadPool();

        final Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    if (semaphore.tryAcquire()) { // 尝试获取一个许可
                        test(threadNum);
                        semaphore.release(); // 释放一个许可
                    }
                    // 未拿到许可，可以丢弃这个线程
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        exec.shutdown();
    }

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

五、CyclicBarrier

允许一组线程进入等待，直到到达某个工作点，然后被释放继续执行

如上设定为3，当一个线程调用await方法时加1，该线程阻塞，直到计数器到达3，所有阻塞线程都可以继续执行，可以实现多个线程相互等待，直到某个条件达成，然后继续共同执行 

该类的核心就是await方法

@Slf4j
public class CyclicBarrierExample1 {

    private static CyclicBarrier barrier = new CyclicBarrier(5);

    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);
    }
}

线程通过await方法进入阻塞，此处阻塞的线程数量到达5个后，所有阻塞的线程放开，继续执行；然后可以有新的线程通过await进入阻塞

六、ReentrantLock与锁

java中有两种锁，一个是synchronized提供的锁，一个是juc中提供的Lock，Lock的核心是ReentrantLock锁

ReentrantLock是可重入锁，类库实现锁，性能与synchronized差不多，功能比synchronized丰富

ReentrantLock可以指定公平锁还是非公平锁，synchronized是非公平锁（先等待的不一定先获得锁）

ReentrantLock提供了一个condition类，可以分组唤醒需要唤醒的线程

ReentrantLock提供中断等待锁的线程的机制

ReentrantLock的实现是一种自旋锁，避免进入在用户态和内核态之间切换，通过不断CAS尝试加锁

在finally中解锁，千万不要忘记解锁

@Slf4j
@ThreadSafe
public class LockExample2 {

    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    public static int count = 0;

    private final static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count);
    }

    private static void add() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

Condition的使用案例

@Slf4j
public class LockExample6 {

    public static void main(String[] args) {
        ReentrantLock reentrantLock = new ReentrantLock();
        Condition condition = reentrantLock.newCondition();

        new Thread(() -> {
            try {
                reentrantLock.lock();
                log.info("wait signal"); // 1
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("get signal"); // 4
            reentrantLock.unlock();
        }).start();

        new Thread(() -> {
            reentrantLock.lock();
            log.info("get lock"); // 2
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            condition.signalAll();
            log.info("send signal ~ "); // 3
            reentrantLock.unlock();
        }).start();
    }
}

condition.await()方法会使得当前线程进入condition队列，释放锁并等待其它线程唤醒，其它线程通过condition.signalAll()方法唤醒condition队列中的线程使其进入AQS等待调度队列，等待调度并获得锁之后继续执行