Java 之 JUC

JUC

JUC 是指 Java 中的三个包：
（1）并发：package java.util.concurrent;
并发和并行：并发是多个线程同时访问一个数据；并行是多个线程同时在做不同的事情。
（2）原子：package java.util.concurrent.atomic;
（3）锁：package java.util.concurrent.locks;

CountDownLatch 类

做减法。
目的是为了让一些线程阻塞，直到另一些线程完成一系列操作后才被唤醒。
主要有两个方法：await 和 countDown 。
当一个或多个线程调用 await 方法时，调用线程会被阻塞。其他线程调用 countDown 方法会将计数器减 1 （调用 countDown 的线程不会阻塞），当计数器的值变为 0 的时候，因调用 await 方法被阻塞的线程会被唤醒，方法继续执行。
下面代码中，我们想让 5 个线程全部执行完毕后，再执行主线程，但是一下代码是否能够满足呢？

public static void main(String[] args ) {
  	for (int i = 1;i <= 5;i++){
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "线程执行！");
        },String.valueOf(i)).start();
    }
    
    System.out.println(Thread.currentThread().getName() + "线程执行！");
}

执行结果其中一种可能：
main线程执行！
2线程执行！
1线程执行！
3线程执行！
4线程执行！
5线程执行！

此时我们可以通过使用 CountDownLatch 来进行控制：

 CountDownLatch countDownLatch = new CountDownLatch(5);
 for (int i = 1;i <= 5;i++){
     new Thread(() -> {
         System.out.println(Thread.currentThread().getName() + "线程执行！");
         countDownLatch.countDown(); // countDownLatch 减 1
     },String.valueOf(i)).start();
 }
 countDownLatch.await(); //主线程阻塞，等待 countDownLatch 变为 0
 System.out.println(Thread.currentThread().getName() + "线程执行！");

执行结果：
1线程执行！
2线程执行！
3线程执行！
5线程执行！
4线程执行！
main线程执行！

CyclicBarrier 类

做加法。
CyclicBarrier 限制的对应数量线程执行完毕后，便会执行 “全部考试结束” ；如果把代码中的 new CyclicBarrier() 中的 5 改为 3，即三个线程执行完毕后，会执行 “全部考试结束”。

public static void main(String[] args ) {
    CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {System.out.println("全部考试结束！");});
    for (int i = 1;i<=5;i++){
        /*
        从 lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量，即不能再对 testNumber 进行修改操作，会编译报错；
        final修饰不可被更改。
         */
        final int testNumber = i;
        new Thread (() ->{
            System.out.println("第" + testNumber + "场考试开始！");
            
            int sum = 0;
            for (int j = 0;j<100;j++){
                sum = sum + j;
            }
            System.out.println("【第" + testNumber + "场考试结束，结果是" + sum + "！】");
            
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        },String.valueOf(i)).start();
    }
}

执行结果：
第3场考试开始！
【第3场考试结束，结果是4950！】
第2场考试开始！
【第2场考试结束，结果是4950！】
第1场考试开始！
【第1场考试结束，结果是4950！】
第5场考试开始！
【第5场考试结束，结果是4950！】
第4场考试开始！
【第4场考试结束，结果是4950！】
全部考试结束！

Semaphore 类

【信号量】，一个是用于多个共享线资源的互斥使用（多线程争抢多个资源），例如：30 辆车抢 20 个车位。可以代替 synchronized 和 Lock。一个是用于并发线程数的控制。

public static void main(String[] args ) {
   Semaphore semaphore = new Semaphore(2);
    for (int i = 1;i<=5;i++){
        new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + "抢到车位！");
                int second = (int)(1+Math.random()*(10-1+1));
                TimeUnit.SECONDS.sleep(second);
                System.out.println(Thread.currentThread().getName() + "停车" + second + "s后离开车位！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 释放
                semaphore.release();
            }
        },String.valueOf(i)).start();
    }
}


执行结果：
2抢到车位！
1抢到车位！
2停车8s后离开车位！
3抢到车位！
1停车10s后离开车位！
4抢到车位！
3停车3s后离开车位！
5抢到车位！
5停车1s后离开车位！
4停车5s后离开车位！

BlockingDeque 接口

阻塞队列。

生产线程向阻塞队列中放入元素，消费线程从阻塞队列中取出元素消费；当阻塞队列为空时，消费线程（Thread 2）从阻塞队列获取元素的操作会被阻塞，没有元素可供消费，当阻塞队列满了时，生产线程（Thread 1）向阻塞队列放入元素的操作会被阻塞。

常用实现类：

ArrayBlockingQueue：由数组结构组成的有界阻塞队列。
LinkedBlockingQueue：由链表结构组成的有界阻塞队列（默认值为Integer.MAX_VALUE = 0x7fffffff 21亿…，很大，所以慎用，界太大了，21亿的链表等于无界了）。
PriorityBlockingQueue：支持优先级排序的无界阻塞队列。
DelayQueue：使用优先级队列实现的延迟无界阻塞队列。
SynchronousQueue：不存储元素的阻塞队列，即单个元素的队列（生产一个消费一个，不消费就不生产，即队列中只有一个）。
LinkedTransferQueue：由链表结构组成的无界阻塞队列。
LinkedBlockingDeque：由链表结构组成的双向阻塞队列。

队列	有界性	锁	数据结构
ArrayBlockingQueue	有界	加锁	arrayList
LinkedBlockingQueue	有界	加锁	linkedList
PriorityBlockingQueue	无界	加锁	heap
DelayQueue	无界	加锁	heap
SynchronousQueue	有界	加锁	无
LinkedTransferQueue	无界	加锁	heap
LinkedBlockingDeque	无界	无锁	heap

方法	报错	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e,time,unit)
移除	remove()	poll(e)	take(e)	poll(time,unit)
检查	element()	peek()	不可用	不可用

抛出异常：
当阻塞队列满了的时候，再往队列里 add 元素会java.lang.IllegalStateException：Queue full；
当阻塞队列空了的时候，再 remove 队列元素会抛出 java.util.NoSuchElementException。
特殊值：
offer 插入，成功返回 true ，失败返回 false；
poll 移除，成功返回移出的元素，没有元素就返回 null。
一直阻塞：
当阻塞队列满了的时候，生产者线程继续往队列里 put 元素，队列会一直阻塞线程直到 put 成功 或者是 相应中断退出；
当阻塞队列空了的时候，消费者线程试图从队列里 take 元素出来，队列会一直阻塞直到队列可用。
超时退出：
当阻塞队列满了的时候，队列会阻塞生产者线程一定时间，超过时间后生产者线程会退出；线程没有满的时候，没有等待，元素会被立即插入。

以报错为例：

public static void main(String[] args ) {
    ArrayBlockingQueue<Integer> arrayBlockingQueue = new ArrayBlockingQueue<Integer>(3);

    System.out.println(arrayBlockingQueue.add(1)); //true
    System.out.println(arrayBlockingQueue.add(2));  //true
    System.out.println(arrayBlockingQueue.add(3));  //true
    //System.out.println(arrayBlockingQueue.add(4)); // 超出限定数量，异常ng.IllegalStateException：Queue full

    System.out.println(arrayBlockingQueue.remove());  //true
    System.out.println(arrayBlockingQueue.remove());  //true
    System.out.println(arrayBlockingQueue.remove());   //true
    //System.out.println(arrayBlockingQueue.remove()); // 报错 java.util.NoSuchElementException
    System.out.println(arrayBlockingQueue.remove(4)); // 注意，此处元素中没有 4 ，但是移除元素 4 返回结果为 false ，不会报错
}

SynchronousQueue 与其他 BlockingDeque 不同，，他没有容量，是一个不存储元素的 BlockingDeque 。
每一个 put 操作必须等待一个 take 操作，否则不能继续添加元素。

public static void main(String[] args ) {
    SynchronousQueue<Integer> synchronousQueue = new SynchronousQueue<>();
    new Thread(() -> {
        System.out.println("add(1)");
        System.out.println(synchronousQueue.add(1));

		//此处会抛出异常：Exception in thread "thread1" java.lang.IllegalStateException: Queue full ，在添加第一个元素后，显示队列已满。
        System.out.println("add(2)");
        System.out.println(synchronousQueue.add(2)); 
    },"thread1").start();
}

使用 take ，因为 thread1 添加完第一个元素后，没有现成取出，则阻塞等待元素被取出，等到元素被取出后，立即添加第二个元素：

public static void main(String[] args ) throws InterruptedException{
    SynchronousQueue<Integer> synchronousQueue = new SynchronousQueue<>();

    new Thread(() -> {
        try {
            System.out.println("put(1)");
            synchronousQueue.put(1);

            System.out.println("put(2)");
            synchronousQueue.put(2);

            System.out.println("put(3)");
            synchronousQueue.put(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    },"thread1").start();
    
    new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(5);
            System.out.println(synchronousQueue.tskr());

            TimeUnit.SECONDS.sleep(5);
            System.out.println(synchronousQueue.take());

            TimeUnit.SECONDS.sleep(5);
            System.out.println(synchronousQueue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    },"thread2").start();
}
输出结果：
put(1)
1
put(2)
2
put(3)
3