JUC详解（二）

本次笔记来自狂神说和尚硅谷

8.常用的辅助类

8.1 CountDownLatch8.2 CyclicBarrier8.3 Semaphore（信号量） 9.读写锁 ReadWriteLock10.阻塞队列

10.1 什么是阻塞队列？10.2 BlockingQueue10.3 队列的四组API10.4 SynchronousQueue 同步队列 11.线程池（重点）

11.1 概念：11.2 线程池:三大方法11.3 7大参数 和 四种拒绝策略

11.3.1 源码（哪些7大参数）11.3.2 举例：11.3.3 四种拒绝策略:（java.util.concurrent） 11.4 手动创建一个线程池 12.四大函数式接口

12.1 Function 函数式接口12.2 Predicate 断定型接口12.3 Consumer 消费型接口12.4 Supplier 供给型接口 13.Stream流式计算

13.1 什么是Stream流式计算13.2 举例 14.JMM

14.1 什么是JMM（保证线程的安全）14.2 举例和8大操作14.4 问题 15.Volatile

15.1 概念15.2 保证可见性15.3 不保证原子性

15.3.1 证明不保证原子性15.3.2 如何保证原子性（原子类） 15.4 禁止指令重排

15.4.1 什么是指令重排：15.4.2 volatile 16.玩转单例模式17.可重入锁（递归锁）18.死锁

18.1 什么是死锁？18.2 产生死锁原因:18.3 代码18.4 验证是否是死锁(deadlock)

CountDownLatch 相对于是一个减法计数器，允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + " Go out");
                countDownLatch.countDown();//数量-1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归零，然后再向下执行
        System.out.println("close Door");
    }
}

结果：
0 Go out
2 Go out
4 Go out
5 Go out
1 Go out
3 Go out
close Door

原理：
countDownLatch.countDown();//数量-1
countDownLatch.await();//等待计数器归零，然后再向下执行
每次有线程调用countDown()数量-1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行！

允许一组线程全部等待彼此达到共同屏障点的同步辅助。

CyclicBarrier 相对于是加法计数器，允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

CyclicBarrier : 指定个数线程执行完毕再执行操作

代码：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //集齐七颗龙珠召唤神龙
        //召换龙族的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> System.out.println("召唤神龙成功！"));
        for (int i = 1; i <= 7; i++) {
            final int temp = i;//临时变量
            //lambda 能操作到 i 吗 不可以
            //lambda本质上就是个类，不可能拿到上面的变量需要转折一下》中间变量，通过final变量
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "收集" + temp + "龙珠");
                try {
                    cyclicBarrier.await();//等待
// 等待7个线程执行完了，上面的计数器到7，每次循环都会加1,到7了，才会完整的走下去（开启新的线程执行）
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

结果：
Thread-0收集1龙珠
Thread-3收集4龙珠
Thread-2收集3龙珠
Thread-1收集2龙珠
Thread-4收集5龙珠
Thread-5收集6龙珠
Thread-6收集7龙珠
召唤神龙成功！

总结：
7个线程执行完了，计数器变成7，它才会完整的走下去。如果改成8，那么程序将会一直执行，停止不了，它要等到了8才会执行那句话。

注意点：
lambda 不能操作到 i 。
lambda本质上就是个类，不可能拿到上面的变量
需要转折一下》中间变量，通过final变量

概念：
一个计数信号量。 在概念上，信号量维持一组许可证。 如果有必要，每个acquire()都会阻塞，直到许可证可用，然后才能使用它。 每个release()添加许可证，潜在地释放阻塞获取方。

》 semaphore 就是一个容器 用它来限制并发的线程数
Semaphore: 同一时间只能有指定数量得到线程

举例：
就比如抢车位！6车但只有3个停车位置，
第一次进来3辆，其他只能等待，有车走，那等待的车就会进来
代码：

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量：停车位！ 限流！一次性只能进来三个
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                //acquire()得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();//release()释放
                    //只有释放了后面的线程才会继续往里走 
                }
            },String.valueOf(i)).start();
        }
    }
}

结果：
1抢到车位
4抢到车位
2抢到车位
1离开车位
2离开车位
4离开车位
3抢到车位
6抢到车位
5抢到车位
5离开车位
3离开车位
6离开车位

注意：
不是说所有车都走才可以进
按道理是走一辆可以进一辆
这里是因为所有车都是停2秒

概念：
semaphore.acquire();
获得，假设如果已经满了，等待，等待被释放为止 !
-1的操作

semaphore.release();//release()释放
释放，会将当前的信号量释放，然后唤醒等待的线程!
+ 1的操作

Semaphore的作用:
多个共享资源互斥的使用!
并发限流，控制最大的线程数!

实现类： ReentrantReadWriteLock

概念：
ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。
read lock可以由多个线程同时进行，write lock是独家的。

（读可以被多线程同时读，写的时候只能有一个线程去写）

作用： 提交效率和性能

举例：
写的时候只希望同时只有一个线程写，
读的时候所有人都可以读，提交性能，
这时候就可以使用ReadWriteLock

注意：
用synchronized 和lock锁可以，但是不能更精细。
下面的例子第一步不加读写锁的话
就会造成 写入的时候会有另一个插入，
达不到想要的先写入再写入ok

总结：
独占锁（写锁） 一次只能被一个线程占有
共享锁（读锁） 多个线程可以同时占有
ReadWriteLock》
读-读 可以共存！
读-写 不能共存！
写-写 不能共存！

代码：

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) {
//        MyCache myCache = new MyCache();
        MyCacheLock myCache = new MyCacheLock();
        //写入
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        //读取
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}

//1
class MyCacheLock{
    private volatile Map map = new HashMap<>();
    //读写锁：更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //存，写入的时候，只希望同时只有一个线程写
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入" + key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "写入ok");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
    //取，读，所有人都可以读
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取" + key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取ok");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

//2
//自定义缓存
class MyCache{
    private volatile Map map = new HashMap<>();
//    volatile保证原子性
    //存，写入的时候，只希望同时只有一个线程写
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName() + "写入" + key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() + "写入ok");
    }
    //取，读，所有人都可以读
    public void get(String key){
        System.out.println(Thread.currentThread().getName() + "读取" + key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取ok");
    }
}

总结：
1.当使用MyCache myCache = new MyCache();时，即调用第二个
结果：
1写入1
1写入ok
3写入3
2写入2
…
1读取1
5写入5
2写入ok
3读取3
3读取ok
…
一看结果就知道不符合
2.当使用MyCacheLock myCache = new MyCacheLock();时，即调用第一个
结果：
1写入1
1写入ok
3写入3
3写入ok
…
2读取2
5读取5
5读取ok
1读取1
1读取ok
…
这时候就对了

双端队列： 两头都会进去 而队列只会从一头进去

队列》先进先出
写入: 如果队列满了,就必须阻塞等待。
取: 如果是队列是空的,必须阻塞等待生产。

这两种情况属于不得不阻塞

Interface BlockingQueue
它的父接口有： Collection
实现类主要有：
ArrayBlockingQueue（数组） ，
linkedBlockingQueue（链表） ，
SynchronousQueue（同步队列）

什么情况下我们会使用阻塞队列:
多线程并发处理和线程池!

学会使用队列主要有添加、移除

" />
四组API
1、抛出异常
2、不会抛出异常（有返回值，没有异常）
3、阻塞等待（一直阻塞 一直等无止尽）
4、超时等待（等待超时 超过了某时间，我就不等了）

代码：

所有的结果都在里面

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        test3();
    }
    //抛出异常
    public static void test1(){
        ArrayBlockingQueue