java并发编程（下篇）

java里的阻塞队列
ArrayBlockingQueue 数组结构组成的有界阻塞队列
LinkedBlockingQeque 链表结构的无界阻塞队列
PriorityBlockingQueue 支持优先级排序的无界阻塞队列
DelayQueue 使用优先级队列实现的无界阻塞队列
LinkedBlockingDeque 链表结构组成的双向队列

并发工具类
CountDownLatch CyclicBarrier Semaphore

/**
 * 需求场景：解析Excel里的数据，此时考虑使用多线程，等到所有解析完成之后，提示解析完成
 * 没有完成就等待 await(3L)也可以设置超时时间
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        //只有等待所有线程执行完之后，才能执行别的线程语句
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "离开教室");
                //每执行完一个，计数器 -1
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }

        //还没执行完就进行等待
        countDownLatch.await();
        System.out.println("班长锁门");
    }
}

/**
 * 用于多个线程计算数据，最后合并计算结果
 */
public class CyclicBarrierTest {
    //创建固定值
    private static final int num = 7;
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(num, () -> {
            System.out.println("条件满足");
        });
        //每次执行 CyclicBarrier 一次障碍数会加一
        for (int i = 1; i <= 7; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "找到一个");
                //等待
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

/**
 * 可以用来控制同时访问特定资源的线程数量，用作流量控制
 * 数据库连接 读取几十个文件，启动多线程并发读取，，而且还有存到数据库
 * 此时数据库的连接只有10个，那么就得使用这个来保证只有10个线程获取到数据库连接
 */
public class SemaphoreTest {
    public static void main(String[] args) {
        //设置许可数量
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <=6 ; i++) {
            new Thread(() -> {
                //抢占
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "强占车位");
                    //设置这个线程要执行的时间
                    Thread.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName() + "离开");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //要释放资源
                    semaphore.release();
                }
            },String.valueOf(i)).start();

        }
    }
}

AQS 抽象队列同步器