java复制代码
// 按照类型分类
• 无锁非阻塞并发队列：ConcurrentLinkedQueue和ConcurrentLinkedDeque
• 普通阻塞队列：基于数组的ArrayBlockingQueue，基于链表的LinkedBlockingQueue和LinkedBlockingDeque
• 优先级阻塞队列：PriorityBlockingQueue
• 延时阻塞队列：DelayQueue
• 其他阻塞队列：SynchronousQueue和LinkedTransferQueue

处理方式	  抛出异常       返回特殊值      一直阻塞         超时退出
插入方法	  add(e)        offer(e)        put(e)           offer(e, time, unit)
移除方法	  remove()	poll()          take()           poll(time, unit)
检查方法	  element()	peek()          不可用           不可用

JAVA复制代码> 一个由数组实现的有界阻塞队列。该队列采用 FIFO 的原则对元素进行排序添加的 
> ArrayBlockingQueue 为有界且固定，其大小在构造时由构造函数来决定，确认之后就不能再改变了
> ArrayBlockingQueue 支持对等待的生产者线程和使用者线程进行排序的可选公平策略
    - 但是在默认情况下不保证线程公平的访问，在构造时可以选择公平策略（fair = true）。
    - 公平性通常会降低吞吐量，但是减少了可变性和避免了“不平衡性”。

// 构造器 : 
MC- ArrayBlockingQueue(int capacity)
MC- ArrayBlockingQueue(int capacity, boolean fair)

// 抽象类和接口 
I- BlockingQueue<E> : 提供了在多线程环境下的出列、入列操作
	?- 内部使用可重入锁 ReentrantLock + Condition 来完成多线程环境的并发操作
	
// 变量
• items 变量，一个定长数组，维护 ArrayBlockingQueue 的元素。
• takeIndex 变量，int ，为 ArrayBlockingQueue 队首位置。
• putIndex 变量，int ，ArrayBlockingQueue 队尾位置。
• count 变量，元素个数。
• lock 变量，ReentrantLock ，ArrayBlockingQueue 出列入列都必须获取该锁，两个步骤共用一个锁。
• notEmpty 变量，非空，即出列条件。
• notFull 变量，未满，即入列条件。

// 入队
M- add(E e) 方法 : 将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true , 满了抛出异常
M- offer(E e) 方法 : 将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true  , 满了返回false
M- offer(E e, long timeout, TimeUnit unit) 方法 : 将指定的元素插入此队列的尾部 , 已满在设定时间内等待
M- put(E e) 方法 : 将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间
M- enqueue : 
	- 正常添加元素 , 到达队尾的时候重定向到队头 
	- 总数 + 1 
	- 通知阻塞线程

// 出列
M- poll() 方法：获取并移除此队列的头，如果此队列为空，则返回 null 。
M- poll(long timeout, TimeUnit unit) 方法：获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。
M- take() 方法：获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。
M- remove(Object o) 方法：从此队列中移除指定元素的单个实例（如果存在）。
        
// 核心总结 : 
M- offer : 通过 ReentrantLock 上锁
    - final ReentrantLock lock = this.lock;
	- lock.lock();
	- finally ->  lock.unlock();

// 关键点 : 
1 创建后，容量将无法更改
2 尝试将元素放入满队列将导致操作阻塞
3 尝试从空队列中取出一个元素]也会类似地被阻塞
4 支持可选的公平性策略

java复制代码支持延时获取元素的无界阻塞队列。里面的元素全部都是“可延期”的元素，列头的元素是最先“到期”的元素
    - 如果队列里面没有元素到期，是不能从列头获取元素的，哪怕有元素也不行。
    - 也就是说只有在延迟期到时才能够从队列中取元素。

// 作用 : 
• 缓存：清掉缓存中超时的缓存数据
• 任务超时处理

// 关键 : 
1. 可重入锁ReentrantLock
2. 用于阻塞和通知的Condition对象
3. 根据Delay时间排序的优先级队列：PriorityQueue
4. 用于优化阻塞通知的线程元素leader
    
// 结构 :     
E- AbstractQueue
I- BlockingQueue
M- offer() : 往PriorityQueue中添加元素
    - 向 PriorityQueue中插入元素
    - 判断当前元素是否为对首元素，如果是的话则设置leader=null , 唤醒所有线程
M- take()    
    - 获取队首 --- q.peek
    IF- 队首为空 , 阻塞 ,等待off 唤醒
    ELSE- 
    	获取队首的超时时间 , 已过期则出对
    - 如果存在其他线程操作 ,阻塞 , 不存在其他线程 , 独占
    - 超时阻塞 --- available.awaitNanos(delay);
    - 唤醒阻塞线程
        
// 使用方式 : 
// Step 1 : new 一个 
DelayQueue queue = new DelayQueue();

// Step 2 : 加东西
queue.offer(createUserDelayQueueTO());

java复制代码C- SynchronousQueue
	E- AbstractQueue
	I- BlockingQueue
C- TransferQueue
	?- 实现公平性策略的核心类，其节点为QNode

java复制代码

// 简介
是先进先出队列FIFO。
采用ReentrantLock保证线程安全

// 操作结果
增加 : 队列满 > 
put -> 一直阻塞
add -> 抛出异常
offer -> 返回false

删除 : 队列为空
remove -> NoSuchElementException
poll -> 返回false
take -> 阻塞


    
// 源码分析
LinkedBlockingQueue
    C- static class Node<E> : 核心静态内部类 , 表示一个节点
		|- E item : 节点原始
         |- Node<E> next : 下一节点
	F- int capacity : 容量界限
	F- AtomicInteger count : 当前元素个数
	F- Node<E> head :头节点
	F- Node<E> last : 尾节点
	F- ReentrantLock takeLock : take,poll等获取锁
	F- Condition notEmpty : 等待任务的等待队列
	F- ReentrantLock putLock : put，offer等插入锁
	F- Condition notFull : 等待插入的等待队列
	MC- LinkedBlockingQueue() : 最大数量
	MC- LinkedBlockingQueue(int capacity) : 指定数量
	MC- LinkedBlockingQueue(Collection<? extends E> c) : 指定集合
	M- signalNotEmpty : 表示等待take。put/offer调用，否则通常不会锁定takeLock
         |- 获取 tackLock : this.takeLock
         |- 锁定takeLock ->  takeLock.lock();
         |- 唤醒take 线程等待队列 -> notEmpty.signal();
         |- 释放锁 -> takeLock.unlock();
	M- signalNotFull : 表示等待put,take/poll 调用
		|- 获取putLock : this.putLock;
		|- 锁定putLock -> putLock.lock();
		|- 唤醒插入线程等待队列 ->  notFull.signal();
		|- 释放锁
	M- enqueue : 在队列尾部插入
		|- last = last.next = node;
	M- E dequeue():移除队列头
		|- 保留头指针
		|- 获取当前链表的第一个元素
		|- 头指针指向第一个元素
		|- 获取第一个元素的值并且移除第一个
		|- 返回第一个元素的值
	M- fullyLock : 锁定putLock和takeLock
 		|- putLock.lock();
		|- takeLock.lock();
	M- fullyUnlock : 先解锁takeLock，再解锁putLock
 		|- putLock.unlock();
	M- offer: 将给定的元素设置到队列中，如果设置成功返回true
		|- 非空判断 , 获取计数器
		|- 判断队列是否已满 -> 返回 Boolean
		|- 新建节点
		|- 获取插入锁 , 并且锁定
		|- 队列未满 -> 插入 -> 计数
		|- 如果未满 ,继续唤醒插入线程
		|- 解锁
		|- 如果对了为空 ,获取线程锁阻塞
	M- offer(E e, long timeout, TimeUnit unit) :给定的时间内设置到队列中
	M- put(E e) : 将元素设置到队列中，如果队列中没有多余的空间，该方法会一直阻塞 , 直到队列中有多余的空间
		|- 核心1 : putLock.lockInterruptibly();
			-> 设置前加锁
		|- 核心2 : notFull.await();
			-> 队列满时等待
	M- take() : 从队列中获取值，如果队列中没有值
	M- peek() : 非阻塞的获取队列中的第一个元素，不出队列
	M- poll() : 非阻塞的获取队列中的值，未获取到返回null。
	M- poll(long timeout, TimeUnit unit) :在给定的时间里，从队列中获取值
	M- remove(Object o):从队列中移除指定的值。将两把锁都锁定。
	M- clear():清空队列。
	M- drainTo(Collection c):将队列中值，全部移除，并发设置到给定的集合中。

java复制代码- PriorityBlockingQueue是支持优先级的无界队列。
- 默认情况下采用自然顺序排序，当然也可以通过自定义Comparator来指定元素的排序顺序。
- PriorityBlockingQueue内部采用二叉堆的实现方式，整个处理过程并不是特别复杂。
- 添加操作则是不断“上冒”，而删除操作则是不断“下掉”。

java复制代码> 阻塞队列 : 阻塞队列有普通的先进先出队列，

> 包括基于数组的ArrayBlockingQueue
> 基于链表的LinkedBlockingQueue/LinkedBlockingDeque
> 基于堆的优先级阻塞队列PriorityBlockingQueue
> 可用于定时任务的延时阻塞队列DelayQueue
> 用于特殊场景的阻塞队列SynchronousQueue和LinkedTransferQueue

java复制代码
优缺点
|- 优点：
	读操作性能很高，比较适用于读多写少的并发场景。
	Java的list在遍历时，若中途有别的线程对list容器进行修改，则会抛出ConcurrentModificationException异常。
	而CopyOnWriteArrayList由于其"读写分离"的思想，遍历和修改操作分别作用在不同的list容器
            ?- 所以在使用迭代器进行遍历时候，也就不会抛出ConcurrentModificationException异常。

|- 缺点：
	内存占用问题，执行写操作时会发生数组拷贝
	无法保证实时性，Vector对于读写操作均加锁同步，可以保证读和写的强一致性。
	而CopyOnWriteArrayList由于其实现策略的原因，写和读分别作用在新老不同容器上
            ?- 在写操作执行过程中，读不会阻塞但读取到的却是老容器的数据。

|- 使用场景 : 
	CopyOnWrite并发容器用于读多写少的并发场景。比如白名单，黑名单，商品类目的访问和更新场景。

CopyOnWriteArrayList
	F- ReentrantLock lock = new ReentrantLock()	--> 重入锁
	F- volatile Object[] array; --> 只能通过 getArray/setArray 访问的数组
	M- Object[] getArray() --> 获取数组，非私有方法以便于CopyOnWriteArraySet类的访问
	M- setArray(Object[] a) --> 设置数组
	M- CopyOnWriteArrayList -- 创建一个空数组
	M- CopyOnWriteArrayList(Collection<? extends E> c) 
		?- 创建一个包含指定集合的数组
		B- 如果c的类类型为CopyOnWriteArrayList 
			|- 直接获取其数组
		E- 如果不是
			|- 通过 toArray 转数组
			|- 如果c.toArray返回的不是 Object[]类型，则通过数组拷贝
		|- 设置数组	: setArray(elements);
	M- 	CopyOnWriteArrayList(E[] toCopyIn) : 创建包含给定数组副本的列表
	M- size() : 获取数量
	M- isEmpty() : 判断列表元素是否为空
	M- eq(Object o1, Object o2) : 判断o1 o2是否相等
	M- indexOf(Object o, Object[] elements,int index, int fence) 
		B- 为null , for 循环迭代第一个 null
		E- 不为 null ,for 循环 eq
	M- lastIndexOf :索引倒叙
	M- contains  : IndexOf 判断
	M- clone : 浅拷贝
		|- 重置锁定
		|- 返回clone 属性 
	M- toArray
	M- get :  获取原数组中元素
	M- set:用指定的元素替换列表中指定位置的元素
		|- 获取当前锁并且锁定
		|- 获取元素数组
		|- 获取老的值 
		B- 如果老的值和给定值不相等
			|- 原数组拷贝 , 将新数组中的索引位置修改为新值
			|- 将原数组替换为新数组
		E- 否则
			|- setArray(elements);
		|- 返回老的值
	M- add(E e) : 将指定的元素追加到此列表的末尾
		|- 获取重入锁 ,锁定
		|- 获取原数组
		|- 原数组拷贝 并增加一个空位
		|- 将指定元素增加到新数组新增的空位中
		|- 新数组替换原数组
	M- 	remove :
		|- 获取锁并且锁定
		|- 获取原数组
		|- 获取要删除的元素值 , 获取要移动的值
		B- 如果为0，则删除的是最后一个元素
			-> setArray(Arrays.copyOf(elements, len - 1));
		E- 否则 复制拷贝
			|- 新建数组
			|- 将原数组中，索引index之前的所有数据，拷贝到新数组中
			|- 将元素组，索引index+1 之后的numMoved个元素，复制到新数组，索引index之后
			|- 替换原数组
		|- 返回老的值 ,最后释放锁
	C- COWSubList : 内部视图类

java复制代码
芋道源码 : http://www.iocoder.cn/JUC/sike/aqs-3/

https://mp.weixin.qq.com/s?__biz=MzIxOTI1NTk5Nw==&mid=2650047475&idx=1&sn=4349ee6ac5e882c536238ed1237e5ba2&chksm=8fde2621b8a9af37df7d0c0a7ef3178d0253abf1e76a682134fce2f2218c93337c7de57835b7&scene=21#wechat_redirect

https://blog.csdn.net/javazejian/article/details/70768369

死磕系列 , 我的多线程导师
http://cmsblogs.com/?cat=151

// JVM 源码 C
https://www.jianshu.com/p/a604f1a9f875

java复制代码// 基本对象
ThreadPoolExecutor 

// 可重用固定线程数的线程池
FixedThreadPool 
	- ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);
	
// 使用单个worker线程的Executor
SingleThreadExecutor 

// 会根据需要创建新线程的线程池
CachedThreadPool

java复制代码return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());

java复制代码return new FinalizableDelegatedExecutorService (
new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));

java复制代码return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());

java复制代码return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1));

java复制代码1 >  Fork / Join 的核心是 ForkJoinPool , 用于来管理工作线程 
	: 工作线程一次只能执行一个任务 ，
	: 不会根据任务创建线程，而是将任务存储到工作线程的双端队列中
2 > Fork / join 的思路是分而治之
    - Fork 递归的将任务分为较小的子任务
    - Join : 将子任务递归的串联成单个结果

3 > 工作窃取算法 : 空闲的线程试图从繁忙的线程（他们的双端队列）中窃取工作
    
// Fork/Join 依赖于 ForkJoinPool , 此处仅简单介绍 , 详情参考十六章

java复制代码ThreadPoolExecutor实现了生产者/消费者模式，
    - 工作者线程就是消费者
    - 任务提交者就是生产者，线程池自己维护任务队列。

> ThreadPoolExecutor 
	- AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
	: 此变量 记录了 “线程池中的任务数量”和“线程池的状态”两个信息
	: 高3位表示"线程池状态"，低29位表示"线程池中的任务数量"
	  - RUNNING : 111 : 该线程池能接收新任务 ,且能对新任务进行处理
	  - SHUTDOWN : 000 : 不能接收新任务 ,但是可以对任务进行处理
	  - STOP : 001 : 不添加新任务 , 不对任务进行处理 , 会中断正在执行的任务
	  - TIDYING : 010 : 当所有的任务已终止，ctl记录的"任务数量"为0，线程池会变为TIDYING状态
	  		- 当所有的任务已终止，ctl记录的"任务数量"为0，线程池会变为TIDYING状态
	  - TERMINATED : 011 : 线程池彻底终止的状态
	
----------------------------------------

> ThreadPoolExecutor 的参数
	- corePoolSize : 线程池中核心线程的数量
	- maximumPoolSize : 线程池中允许的最大线程数
	- keepAliveTime : 线程空闲的时间
	- unit : keepAliveTime的单位
	- workQueue : 用来保存等待执行的任务的阻塞队列，等待的任务必须实现Runnable接口
	- threadFactory : 用于设置创建线程的工厂
	- allowCoreThreadTimeOut : 允许核心线程过期
	- Handler : 处理器
            - defaultHandler : 任务拒绝处理器

java复制代码// 线程池的饱和策略 , 当线程池满了.  会通过对应的策略
1、AbortPolicy：直接抛出异常，默认策略；
2、CallerRunsPolicy：用调用者所在的线程来执行任务；
3、DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
4、DiscardPolicy：直接丢弃任务；


// ThreadPoolExecutor 提供了动态调整线程池容量大小的方法：
• setCorePoolSize：设置核心池大小。
• setMaximumPoolSize：设置线程池最大能创建的线程数目大小。
当上述参数从小变大时，ThreadPoolExecutor 进行线程赋值，还可能立即创建新的线程来执行任务。

// 动态调整源码核心 :

java复制代码// 问题一 : Worker 结构
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
    
    // 被封装的线程
    final Thread thread;
    // 初始任务
    Runnable firstTask;
    // 线程任务计数器
    volatile long completedTasks;

    // 可以看到 , 把 worker 都行构建成了 Thread
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

  
    public void run() {
        runWorker(this);
    }

    protected boolean isHeldExclusively() {....}
    // 获取同步状态
    protected boolean tryAcquire(int unused) {....}
    // 释放同步状态
    protected boolean tryRelease(int unused) {....}
    
    //锁操作
    public void lock()        { acquire(1); }
    public boolean tryLock()  { return tryAcquire(1); }
    public void unlock()      { release(1); }
    public boolean isLocked() { return isHeldExclusively(); }

    // 暂停操作
    void interruptIfStarted(){....}
}

// 问题二 : ThreadPoolExecutor中的线程包装
- 线程被封装成一个对象Worker
- 通过调用 runWorker(Worker w) 获取任务并执行的死循环 
- 如果任务的运行出了什么问题 ,调用 processWorkerExit() 处理
    
C- ThreadPoolExecutor
    PVC- Worker
    	M- run : public void run() {runWorker(this); }

java复制代码public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

java复制代码// task 的构建 : 匿名传进来的线程会构建成一个 FutureTask
RunnableFuture<Void> ftask = newTaskFor(task, null);

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}

java复制代码// 问题一 : execute 中线程池处理任务的逻辑
1	        int c = ctl.get();
2	        if (workerCountOf(c) < corePoolSize) {
3	            if (addWorker(command, true))
4	                return;
5	            c = ctl.get();
6	        }
7	        if (isRunning(c) && workQueue.offer(command)) {
8	            int recheck = ctl.get();
9	            if (! isRunning(recheck) && remove(command))
10	                reject(command);
11	            else if (workerCountOf(recheck) == 0)
12	                addWorker(null, false);
13	        }
14	        else if (!addWorker(command, false))
15	            reject(command);
     
// 2 : workerCountOf 判断当前线程数是否小于corePoolSize 从而决定是否通过 addWorker 创建线程
// 7 : 如果线程池已满 ,且状态为 running , 尝试把任务添加到 workQueue
// 14 : 如果 7 步处理失败 , 尝试 addWorker , 失败则通过 reject 处理  


//补充 : addWork 作用
- 检查是否可以根据当前池状态和给定边界(核心或最大)添加新的工作者 
- 创建并启动新的worker，运行firstTask作为它的第一个任务

java复制代码// 问题二 : 线程池运行 Work 详情 (简述一下就是核心的四步)
1 addWorker(Runnable firstTask, boolean core)  : 可以看到addWorker 添加的是一个 Runnable
2 new Worker(firstTask) :如果状态符合 ,会创建一个 Worker 对象
Worker(Runnable firstTask) {
    setState(-1); // inhibit interrupts until runWorker
    this.firstTask = firstTask;
    this.thread = getThreadFactory().newThread(this);
} 
3 final Thread t = w.thread;
    ?- 这里将Thread 取了出来
    
4 后文将会 t.start()运行  

// 补充 : 期间还会进行锁的处理 , 省略一些的主要流程如下
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // 核心一 : 状态判断
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
        
        // 核心二 : 容量满了的处理 , 退出或者重试 (可以看到 c 语言的影子)
        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        // 核心三 : 处理开始
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                int rs = runStateOf(ctl.get());

                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                // 核心四 : 启动线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

java复制代码// 问题四 : 创建工厂
从上文说到 , 线程池通过 ThreadFactory 创建线程 (newThread()) ,

java复制代码// 这个问题涉及到的方法主要包括 getTask () 
M- runWorker
     while (task != null || (task = getTask()) != null) : 死循环 , 只要还有 task 就会执行
         - task.run() : 获取到 task 后 通过 task run 执行
         
M- getTask()
     workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
     workQueue.take();
     
// 补充 : 这里可以看到 , worker 可以理解为一个工作线程 ,他通过 while 不停的从 queue 中获取 task 执行

// 这里很有趣 , worker 更像一个加工工厂 , 我一开始还以为迭代的是 worker , 现在发现是在 worker 上锁后在里面迭代
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // task 实际上不是 worker 的内部属性
        while (task != null || (task = getTask()) != null) {
            // 上锁
            w.lock();
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                beforeExecute(wt, task);
                // 线程执行
                task.run();
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

java复制代码// 瞅一瞅拒绝策略 : 
当你的线程池满了后 , 通常这个异常就爆出来了
java.util.concurrent.RejectedExecutionException:
    Task java.util.concurrent.FutureTask@523424b5 rejected from
    java.util.concurrent.ThreadPoolExecutor@319dead1
    [Running, pool size = 6, active threads = 6, queued tasks = 3, completed tasks = 0]

- 尽管我们可以通过拒绝策略有很多种 ,但是超高并发的时候哪一种都不靠谱 , 所以我们先看下 , 这个拒绝策略怎么来的
    1 从问题三代码的第七行我们就能看到 workQueue.offer(command) , queue 已经 offer 失败了 , 说明Queue 也满了
    2 到14行 , 再次通过 addWork 直接运行 , 失败了
    3 执行了 reject 方法 , handler.rejectedExecution(command, this);
            ?- handler 是接口 ,他有四个实现类 , 具体含义可以见上文拒绝策略 
    4 例如 AbortPolicy 就是 throw new RejectedExecutionException , CallerRunsPolicy 就是再次run 
    (主线程慢慢跑 , 肯定慢的)

- 所以部分业务我们要改 , 怎么改 ? 
    1 spring 里面可以自定义你的拒绝策略 , 可以参考这一篇的用法
        @ https://blog.csdn.net/tanglei6636/article/details/90721801
    2 ThreadPoolExecutor 构造器里面也有
    
- 改的思路 ?
    前提一是集群已经无法解决 (基本上现阶段集群都能满足) ,且你无法节流
    1 放到消息队列
    2 入库 
    3 写盘
    4 放集合 , 单独一个线程 , 用一个取一个

java复制代码1 checkShutdownAccess 校验是否可以关闭
2 RunState 改为 STOP
3 ReentrantLock and isInterrupted
4 drainQueue : remove queue 队列

java复制代码submit 回调
- <T> Future<T> submit(Callable<T> task)
        ?- 很明显 , submit 返回的是 Future , 这就意味着主线程能阻塞等待
        - RunnableFuture<T> ftask = newTaskFor(task);

java复制代码> private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    ?- 线程池里面通过 ctl 来判断线程的状态 , 前面说了线程池高3位表示 "线程池状态"，低29位表示线程池中的任务数量-
    ?- 以 STOP 状态为例 , 在运行的时候 ,他的十进制值为 536870912
        - 首先 ,我们将他转换为二进制 -> 10000 00000 00000 00000 00000 00000
        - 获取后面的29位 ,然后前面补齐 , 最后的高三位即为 001
    ?- 而 TIDYING 对应的就是 00001 00000 00000 00000 00000 00000 00000 -> 010
    ?- RUNNING 为 -1 , 按照为数不多的一点残留知识 , 这里说成111是因为负数按照补码表示的原因
    ?- 众所周知 , 二进制处理的效率最高 ,所以这么玩合情合理

java复制代码> 计算密集型 :Ncpu + 1
    
> 包含了 I/O和其他阻塞操作的任务 : Nthreads = Ncpu x Ucpu x (1 + W/C)
　　Ncpu = CPU的数量
　　Ucpu = 目标CPU的使用率， 0 <= Ucpu <= 1
　　W/C = 等待时间与计算时间的比率
    
> IO密集型 = 2Ncpu

java复制代码1 > public static final int SIZE = 32;
	?- 用二进制补码形式表示int值的位数
2 >  private static final int COUNT_BITS = Integer.SIZE - 3;
3 >  private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
4 >  private static int workerCountOf(int c)  { return c & CAPACITY; }

// 原因一 : 还是状态的原因 , 低 29 位才是 线程数量 , 加上这个参数才能包装低 29 二进制时最开始为 0

java复制代码
// 构造一个线程池 , 推荐用法 
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 6, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3));


// 除了测试 , 尽量避免使用以下方法构建线程池
// 线程创建
// 1 CachedThreadPool
ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
executor.submit(() -> {}
  
// 2 FixedThreadPool
ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);
executor.submit(() -> {}

// 3 SingleThreadExecutor
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(() -> {}

// 4 SingleThreadScheduledExecutor
ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
executor.scheduleWithFixedDelay(() -> {}
                                
                                
// 线程池的关闭
executor.shutdown();
executor.shutdownNow();
                                
// 信息获取
executor.isTerminated() : 是否关闭
executor.getPoolSize()   
executor.getQueue().size()

java复制代码// 使用线程池时有一些规约和建议是需要注意的 : 
	- 创建线程或线程池时请指定有意义的线程名称 
	- 线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式
        	- 并且不建议创建无界线程 , 避免 OOM
	- 必须回收自定义的 ThreadLocal 变量，尤其在线程池场景下

// 注意点 : 
	- 注意线程池的拒绝策略 , 当线程池满了时 , 可能会因为策略带来系统崩溃
	- newCachedThreadPool 也有可能出现 OOM , 其最大值为 newCachedThreadPool 
	-

java复制代码├─系统管理
│  ├─用户管理
│  ├─角色管理
│  ├─菜单管理
│  ├─权限设置（支持按钮权限、数据权限）
│  ├─表单权限（控制字段禁用、隐藏）
│  ├─部门管理
│  ├─我的部门（二级管理员）
│  └─字典管理
│  └─分类字典
│  └─系统公告
│  └─职务管理
│  └─通讯录
│  └─多租户管理
├─消息中心
│  ├─消息管理
│  ├─模板管理
├─代码生成器(低代码)
│  ├─代码生成器功能（一键生成前后端代码，生成后无需修改直接用，绝对是后端开发福音）
│  ├─代码生成器模板（提供4套模板，分别支持单表和一对多模型，不同风格选择）
│  ├─代码生成器模板（生成代码，自带excel导入导出）
│  ├─查询过滤器（查询逻辑无需编码，系统根据页面配置自动生成）
│  ├─高级查询器（弹窗自动组合查询条件）
│  ├─Excel导入导出工具集成（支持单表，一对多 导入导出）
│  ├─平台移动自适应支持
├─系统监控
│  ├─Gateway路由网关
│  ├─性能扫描监控
│  │  ├─监控 Redis
│  │  ├─Tomcat
│  │  ├─jvm
│  │  ├─服务器信息
│  │  ├─请求追踪
│  │  ├─磁盘监控
│  ├─定时任务
│  ├─系统日志
│  ├─消息中心（支持短信、邮件、微信推送等等）
│  ├─数据日志（记录数据快照，可对比快照，查看数据变更情况）
│  ├─系统通知
│  ├─SQL监控
│  ├─swagger-ui(在线接口文档)
│─报表示例
│  ├─曲线图
│  └─饼状图
│  └─柱状图
│  └─折线图
│  └─面积图
│  └─雷达图
│  └─仪表图
│  └─进度条
│  └─排名列表
│  └─等等
│─大屏模板
│  ├─作战指挥中心大屏
│  └─物流服务中心大屏
│─常用示例
│  ├─自定义组件
│  ├─对象存储(对接阿里云)
│  ├─JVXETable示例（各种复杂ERP布局示例）
│  ├─单表模型例子
│  └─一对多模型例子
│  └─打印例子
│  └─一对多TAB例子
│  └─内嵌table例子
│  └─常用选择组件
│  └─异步树table
│  └─接口模拟测试
│  └─表格合计示例
│  └─异步树列表示例
│  └─一对多JEditable
│  └─JEditable组件示例
│  └─图片拖拽排序
│  └─图片翻页
│  └─图片预览
│  └─PDF预览
│  └─分屏功能
│─封装通用组件 
│  ├─行编辑表格JEditableTable
│  └─省略显示组件
│  └─时间控件
│  └─高级查询
│  └─用户选择组件
│  └─报表组件封装
│  └─字典组件
│  └─下拉多选组件
│  └─选人组件
│  └─选部门组件
│  └─通过部门选人组件
│  └─封装曲线、柱状图、饼状图、折线图等等报表的组件（经过封装，使用简单）
│  └─在线code编辑器
│  └─上传文件组件
│  └─验证码组件
│  └─树列表组件
│  └─表单禁用组件
│  └─等等
│─更多页面模板
│  ├─各种高级表单
│  ├─各种列表效果
│  └─结果页面
│  └─异常页面
│  └─个人页面
├─高级功能
│  ├─系统编码规则
│  ├─提供单点登录CAS集成方案
│  ├─提供APP发布方案
│  ├─集成Websocket消息通知机制
├─Online在线开发(低代码)
│  ├─Online在线表单 - 功能已开放
│  ├─Online代码生成器 - 功能已开放
│  ├─Online在线报表 - 功能已开放
│  ├─Online在线图表(暂不开源)
│  ├─Online图表模板配置(暂不开源)
│  ├─Online布局设计(暂不开源)
│  ├─多数据源管理 - 功能已开放
├─积木报表设计器(低代码)
│  ├─打印设计器
│  ├─数据报表设计
│  ├─图形报表设计（支持echart）
│  ├─大屏设计器(暂不开源)
│─流程模块功能 (暂不开源)
│  ├─流程设计器
│  ├─在线表单设计
│  └─我的任务
│  └─历史流程
│  └─历史流程
│  └─流程实例管理
│  └─流程监听管理
│  └─流程表达式
│  └─我发起的流程
│  └─我的抄送
│  └─流程委派、抄送、跳转
│  └─。。。
└─其他模块
   └─更多功能开发中。。

bash复制代码git clone https://github.com/zhangdaiscott/jeecg-boot.git
cd  jeecg-boot/ant-design-jeecg-vue

java复制代码# 安装yarn
npm install -g yarn

# 下载依赖
yarn install

# 启动
yarn run serve

# 编译项目
yarn run build

# Lints and fixes files
yarn run lint

css复制代码  css: {
    loaderOptions: {
      less: {
        modifyVars: {
          /* less 变量覆盖，用于自定义 ant design 主题 */

          'primary-color': '#F5222D',
          'link-color': '#F5222D',
          'border-radius-base': '4px',
        },
        javascriptEnabled: true,
      }
    }
  }

java复制代码@WebFilter(urlPatterns = "/api/*")
public class AccessFilter implements Filter

java复制代码public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest httpServletRequest = (HttpServletRequest) request;
    HttpServletResponse httpServletResponse = (HttpServletResponse) response;
    String userAccount = request.getParameter(Constants.USER_ACCOUNT_KEY);

    //校验用户token 是否存在缓存
    if (spConsumerCacheService.checkUserIdmTokenCache(userAccount)) {
        chain.doFilter(request, response);
    } else {
        // 建立用户 session
        setGotoURLOnSession(httpServletRequest);
        // 重定向用户请求进行 SAML 认证
        // 构建 SAML 认证请求 AuthnRequest
    		AuthnRequest authnRequest = buildAuthnRequest(request);
        // 重定向用户请求到 SAML IDP Server 
    		redirectUserWithRequest(httpServletResponse, authnRequest);    
    }
}

java复制代码private AuthnRequest buildAuthnRequest(HttpServletRequest request) {
    //构建 AuthnRequest
    AuthnRequest authnRequest = OpenSAMLUtils.buildSAMLObject(AuthnRequest.class);
    //设置请求时间
    authnRequest.setIssueInstant(new DateTime());
    //The binding required to transmit the resulting SAML Assertion
    //绑定协议为 urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Artifact
    authnRequest.setProtocolBinding(SAMLConstants.SAML2_ARTIFACT_BINDING_URI);
    //IDP server 认证地址
    authnRequest.setDestination(idpEndpoint.getSSOEndPoint());
    //IDP 验证成功后 接收 SAML Assertion 地址
    authnRequest.setAssertionConsumerServiceURL(idpEndpoint.getSpConsumer());
    //Setting ID of the request
    authnRequest.setID(OpenSAMLUtils.generateSecureRandomId());
    //This is the identification of the sender
    //发起人身份，SP ID
    authnRequest.setIssuer(buildIssuer(request));
    //NameID is the IDP identifier for the user
    //the requested authentication context is the SP's requirements for the authentication,
    // which includes; how the SP wants the IDP to authenticate the user
    authnRequest.setRequestedAuthnContext(buildRequestedAuthnContext());
    LOGGER.info("AuthnRequest Object is {}", authnRequest.toString());
    return authnRequest;
}

java复制代码private void redirectUserWithRequest(HttpServletResponse httpServletResponse, AuthnRequest authnRequest) {

    //BasicSAMLMessageContext was used to contain all the information about the SAML message
    MessageContext context = new MessageContext();
    // 存放 SAML authnRequest 请求
    context.setMessage(authnRequest);

    SAMLBindingContext bindingContext = context.getSubcontext(SAMLBindingContext.class, true);
    // 中继状态值，进行制作 SP 访问的签名
    bindingContext.setRelayState(Constants.IDENTIFY_RELAY_STATE);

    //A context containing information about a peer entity
    // in other words, the IdP for the SP and vice versa
    SAMLPeerEntityContext peerEntityContext = context.getSubcontext(SAMLPeerEntityContext.class, true);
    // peer entity itself does not contain much information, but usually contain one or more sub-context,
    // such as SAMLEndpointContext,SecurityParametersContext,SAMLMessageInfoContext
    // SAMLEndpointContext one of sub-context  - this context contains information about a specific endpoint of the peer entity
    SAMLEndpointContext endpointContext = peerEntityContext.getSubcontext(SAMLEndpointContext.class, true);
    endpointContext.setEndpoint(getIPDEndpoint());

    //携带签名
    SignatureSigningParameters signatureSigningParameters = new SignatureSigningParameters();
    signatureSigningParameters.setSigningCredential(SPCredentials.getCredential());
    signatureSigningParameters.setSignatureAlgorithm(SignatureConstants.ALGO_ID_SIGNATURE_RSA_SHA256);
    context.getSubcontext(SecurityParametersContext.class, true).setSignatureSigningParameters(signatureSigningParameters);

    // SAML 2.0 HTTP Redirect encoder using the DEFLATE encoding method. 
    // This encoder only supports DEFLATE compression and DSA-SHA1 and RSA-SHA1 signatures.
    HTTPRedirectDeflateEncoder encoder = new HTTPRedirectDeflateEncoder();
    encoder.setMessageContext(context);
    encoder.setHttpServletResponse(httpServletResponse);

    try {
        encoder.initialize();
    } catch (ComponentInitializationException e) {
        throw new RuntimeException(e);
    }

    LOGGER.info("AuthnRequest: ");
    OpenSAMLUtils.logSAMLObject(authnRequest);

    LOGGER.info("Redirecting to IDP");
    try {
        encoder.encode();
    } catch (MessageEncodingException e) {
        throw new RuntimeException(e);
    }
}

java复制代码/**
 * 验证签名的逻辑在 SignatureVerifyFilter 中
 *
 * @param request
 * @param response
 */
@GetMapping("/saml/idp/sso")
public void ssoSaml(HttpServletRequest request, HttpServletResponse response)

java复制代码/**
 * <功能描述> idp sso 签名验证过滤器
 *
 * @date 2021/2/27 18:04
 */
@WebFilter(urlPatterns = "/saml/idp/sso")
public class SignatureVerifyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        //获取 SP 签名
        String authRequest = request.getParameter("SAMLRequest");
        String signature = request.getParameter("Signature");
        String signatureMethod = request.getParameter("SigAlg");
        String relayState = request.getParameter("RelayState");
        byte[] signatureBytes = Base64Support.decode(signature);

        //获取 sigMaterial
        URLBuilder urlBuilder = new URLBuilder(httpServletRequest.getRequestURL().toString());
        List<Pair<String, String>> queryParams = urlBuilder.getQueryParams();
        queryParams.clear();
        queryParams.add(new Pair<>("SAMLRequest", authRequest));
        queryParams.add(new Pair<>("RelayState", relayState));
        queryParams.add(new Pair<>("SigAlg", signatureMethod));
        String sigMaterial = urlBuilder.buildQueryString();

        //进行签名验证
        try {
            boolean verified = XMLSigningUtil.verifyWithURI(SPCredentials.getCredential(), signatureMethod, signatureBytes, sigMaterial.getBytes(StandardCharsets.UTF_8));
            if (!verified) {
                throw new BizBaseException(ExceptionCode.SIGNATURE_VERIFIED_ERROR);
            }
        } catch (SecurityException e) {
            throw new BizBaseException(ExceptionCode.SIGNATURE_VERIFIED_ERROR);
        }
        chain.doFilter(request, response);
    }
}

java复制代码// SAML 2.0 HTTP Redirect decoder using the DEFLATE encoding method. 
// This decoder only supports DEFLATE compression.
HTTPRedirectDeflateDecoder decoder = new HTTPRedirectDeflateDecoder();
BasicParserPool parserPool = new BasicParserPool();
try {
    parserPool.initialize();
    decoder.setParserPool(parserPool);
    decoder.setHttpServletRequest(request);
    decoder.initialize();
    decoder.decode();
} catch (ComponentInitializationException | MessageDecodingException e) {
    LOGGER.error("HTTP DECODE ERROR:{}", e.getMessage());
    throw new BizBaseException(ExceptionCode.HTTP_DECODER);
}

//获取 SP 请求信息
MessageContext<SAMLObject> messageContext = decoder.getMessageContext();
AuthnRequest authnRequest = (AuthnRequest) messageContext.getMessage();

//获取 SP 发起者信息
IdentifyIssuerDTO issuerDTO = JacksonUtil.parse(authnRequest.getIssuer().getValue(), new TypeReference<IdentifyIssuerDTO>() {
});

//TODO 校验账号是否存在

java复制代码resp.sendRedirect(SPConstants.ASSERTION_CONSUMER_SERVICE + "?SAMLart=AAQAAMFbLinlXaCM%2BFIxiDwGOLAy2T71gbpO7ZhNzAgEANlB90ECfpNEVLg%3D");

java复制代码/**
 * Artifact 和 Artifact Resolution 处理逻辑在 ConsumerFilter
 *
 * @param userAccount
 * @param request
 * @return
 */
@GetMapping("/consumer")
public JsonResult<IdmToken> spAccessConsumer(@RequestParam(value = "userAccount") String userAccount, HttpServletRequest request)

java复制代码public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse resp = (HttpServletResponse) response;

    // SP 创建一个 ArtifactResolve 对象
    // 附上 从 IDP Server 带上的 Artifact 对象
    LOGGER.info("Artifact received");
    Artifact artifact = buildArtifactFromRequest(req);
    LOGGER.info("Artifact: " + artifact.getArtifact());

    //从request session 上下文中获取 userAccount
    String userAccount = (String) req.getSession().getAttribute(Constants.USER_ACCOUNT_KEY);
    //构建 artifactResolve 对象
    ArtifactResolve artifactResolve = buildArtifactResolve(artifact, userAccount);
    LOGGER.info("Sending ArtifactResolve");
    LOGGER.info("ArtifactResolve: ");
    OpenSAMLUtils.logSAMLObject(artifactResolve);

    //向 IDP 发送 ArtifactResolve 获取 Artifact 对象
    //通过 web service
    ArtifactResponse artifactResponse = sendAndReceiveArtifactResolve(artifactResolve, resp);
    LOGGER.info("ArtifactResponse received");
    LOGGER.info("ArtifactResponse: ");
    OpenSAMLUtils.logSAMLObject(artifactResponse);

    // 验证返回 ArtifactResponse 请求地址和请求时间
    validateDestinationAndLifetime(artifactResponse, req);

    // 获取存有用户信息的 Assertion 断言
    EncryptedAssertion encryptedAssertion = getEncryptedAssertion(artifactResponse);
    Assertion assertion = decryptAssertion(encryptedAssertion);

    // 验证 IDP 签名
    verifyAssertionSignature(assertion);
    LOGGER.info("Decrypted Assertion: ");
    OpenSAMLUtils.logSAMLObject(assertion);

    //获取Assertion 用户属性
    getAssertionAttributes(assertion, req);

    chain.doFilter(req, resp);
}

java复制代码public void resolveArtifact(HttpServletRequest req, HttpServletResponse resp) {
    LOGGER.info("recieved artifactResolve:");
    //初始化 SOAP decoder
    HTTPSOAP11Decoder decoder = new HTTPSOAP11Decoder();
    decoder.setHttpServletRequest(req);
    try {
        BasicParserPool parserPool = new BasicParserPool();
        parserPool.initialize();
        decoder.setParserPool(parserPool);
        decoder.initialize();
        decoder.decode();
    } catch (MessageDecodingException | ComponentInitializationException e) {
        throw new BizBaseException(ExceptionCode.HTTP_SOAP11DECODER_ERROR);
    }

    //获取 artifactResolve 对象
    ArtifactResolve artifactResolve = (ArtifactResolve) decoder.getMessageContext().getMessage();
    LOGGER.info("ArtifactResolve:");
    OpenSAMLUtils.logSAMLObject(artifactResolve);

    //获取 SP 发起人身份
    Issuer issuer = artifactResolve.getIssuer();
    IdentifyIssuerDTO issuerDTO = JacksonUtil.parse(issuer.getValue(), new TypeReference<IdentifyIssuerDTO>() {
    });
    String userAccount = issuerDTO.getUserAccount();
    String spConsumerUrl = issuerDTO.getConsumerUrl();
    
    //构建 Artifact Response 对象
    ArtifactResponse artifactResponse = buildArtifactResponse(userAccount, spConsumerUrl);
    MessageContext<SAMLObject> context = new MessageContext<SAMLObject>();
    context.setMessage(artifactResponse);

    //发送 response 到 SP
    HTTPSOAP11Encoder encoder = new HTTPSOAP11Encoder();
    encoder.setMessageContext(context);
    encoder.setHttpServletResponse(resp);
    try {
        encoder.prepareContext();
        encoder.initialize();
        encoder.encode();
    } catch (MessageEncodingException | ComponentInitializationException e) {
        throw new RuntimeException(e);
    }
}

java复制代码// 从上下文中获取用户访问的 target 地址
// 进行重定向
private void redirectToGotoURL(HttpServletRequest req, HttpServletResponse resp) {
    String gotoURL = (String)req.getSession().getAttribute(SPConstants.GOTO_URL_SESSION_ATTRIBUTE);
    logger.info("Redirecting to requested URL: " + gotoURL);
    try {
        resp.sendRedirect(gotoURL);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

JAVA复制代码do{   
       备份旧数据；  
       基于旧数据构造新数据；  
}while(!CAS( 内存地址，备份的旧数据，新数据 ))

JAVA复制代码     
// CPU 结构简述 : 
- 每个CPU有cache（CPU内部的高速缓存，寄存器）
- 管芯内还带有一个互联模块，使管芯内的两个核可以互相通信
- 系统互联模块可以让四个管芯相互通信，并且将管芯与主存连接起来
        
// 数据流动
- 数据以“缓存线”为单位在系统中传输，“缓存线”对应于内存中一个 2 的幂大小的字节块，大小通常为 32 到 256 字节之间
- 当 CPU 从内存中读取一个变量到它的寄存器中时，必须首先将包含了该变量的缓存线读取到 CPU 高速缓存
- CPU 将寄存器中的一个值存储到内存时，不仅必须将包含了该值的缓存线读到 CPU 高速缓存，
    还必须确保没有其他 CPU 拥有该缓存线的拷贝 
    
// 转变流程
• CPU0 检查本地高速缓存，没有找到缓存线。
• 请求被转发到 CPU0 和 CPU1 的互联模块，检查 CPU1 的本地高速缓存，没有找到缓存线。
• 请求被转发到系统互联模块，检查其他三个管芯，得知缓存线被 CPU6和 CPU7 所在的管芯持有。
• 请求被转发到 CPU6 和 CPU7 的互联模块，检查这两个 CPU 的高速缓存，在 CPU7 的高速缓存中找到缓存线。
• CPU7 将缓存线发送给所属的互联模块，并且刷新自己高速缓存中的缓存线。
• CPU6 和 CPU7 的互联模块将缓存线发送给系统互联模块。
• 系统互联模块将缓存线发送给 CPU0 和 CPU1 的互联模块。
• CPU0 和 CPU1 的互联模块将缓存线发送给 CPU0 的高速缓存。
• CPU0 现在可以对高速缓存中的变量执行 CAS 操作了 
    
//效率问题
最好情况 : 某一个变量执行 CAS 操作的 CPU 正好是最后一个操作该变量的CPU

java复制代码// Java 里面 CAS 操作主要通过 Native 方法完成 , 主要的操作对象有 : Unsafe 

C- Unsafe
    - 提供了硬件级别的原子操作
	- 对于Unsafe类的使用都是受限制的，只有授信的代码才能获得该类的实例
	M- public native long allocateMemory(long paramLong) : 
	M- public native long reallocateMemory(long paramLong1, long paramLong2) : 扩充内存
	M- public native void freeMemory(long paramLong) : 释放内存
    
    
// 例如 AQS 里面 : 
> AbstractQueuedSynchronizer
	return unsafe.compareAndSwapObject(this, headOffset, null, update);

java复制代码@ https://blog.csdn.net/qq_37113604/article/details/81582784

// .c 文件 sun.misc.Unsafe
public final native boolean compareAndSwapInt(Object o, long offset,int expected, int x);

// C 源码
#define LOCK_IF_MP(mp) __asm cmp mp, 0  \
                       __asm je L0      \
                       __asm _emit 0xF0 \
                       __asm L0:
 
inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  // alternative for InterlockedCompareExchange
  int mp = os::is_MP();
  __asm {
    mov edx, dest
    mov ecx, exchange_value
    mov eax, compare_value
    LOCK_IF_MP(mp)
    cmpxchg dword ptr [edx], ecx
  }
}

java复制代码// 等待具体时间
> sleep(time) 
    // 该方式不释放锁 ，低优先级有机会执行
    // sleep 后转入 阻塞（blocked）
> wait(time)
> join(time)
> LockSupport.parkNanos()
> LockSupport.parkUnit()
> yield
	// 该方式同样不会释放锁 ，同优先级及高优先级执行
	// 执行后转入ready
	
// 仅 进入等待
> wait()
> join()
> LockSuppot.park()

java复制代码// 对于设定具体等待时间的 timeout 后自动转入就绪

// 其他等待
> notify()
> notifyAll()

> 不同线程之间采用字符串作为监视器锁，会唤醒别的线程
> 不同线程之间的信号没有共享，等待线程被唤醒后继续进入wait状态：
    
    
    
> 下图为不同线程的等待与唤醒

java复制代码> 执行wait () 时释放锁 , 否则等待的线程如果继续持有锁 , 其他线程就没办法获取锁 , 会陷入死锁

// Wait - Notify 深入知识点
// 一 : Wait 等待知识点
- 当前线程必须拥有这个对象的监视器
    
    
// 二 : Wait 等待后    
- 执行等待后 , 当前线程将自己放在该对象的等待集中，然后放弃该对象上的所有同步声明 
- 如果当前线程在等待之前或等待期间被任何线程中断 , 会抛出 InterruptedException 异常    
    
    
// 三 : 唤醒时注意点
- Notify 唤醒一个正在等待这个对象的线程监控 (monitor)
- 执行 wait 时会释放锁 , 同时执行 notify 后也会释放锁 (如下图)
- notify 会任意选择一个等待对象来提醒

// 四 : 唤醒后知识点
- 线程唤醒后 , 仍然要等待该对象的锁被释放
- 线程唤醒后 , 将会与任何竞争该锁的对象公平竞争
    
    
// 假醒 : 
线程也可以在不被通知、中断或超时的情况下被唤醒，这就是所谓的伪唤醒。

java复制代码> interrupt() 
// 方法，用于中断线程。调用该方法的线程的状态为将被置为”中断”状态。

> interrupted ()
// 查询当前线程的中断状态，并且清除原状态。
	
> isInterrupted ()
// 查询指定线程的中断状态，不会清除原状态+
    
// interrupt() 方法干了什么 ? 
public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
 }    

// 1 checkAccess() : 其中涉及到 SecurityManager , 所以我们先看看这个类干什么的
	- SecurityManager security = System.getSecurityManager();
	- security.checkAccess(this);
	
C- SecurityManager : 
	?- 这是 Java.lang 底下的一个类

java复制代码// 资源的分类
- 可抢占资源 : 可抢占资源指某进程在获得这类资源后，该资源可以再被其他进程或系统抢占 , 例如 CPU 资源
- 不可抢占资源 

// 死锁的常见原因 : 
- 竞争不可抢占资源引起死锁 (共享文件)
- 竞争可消耗资源引起死 (程通信时)
- 进程推进顺序不当引起死锁
    
// 死锁的预防
- 通过系统中尽量破坏死锁的条件 , 当四大条件有一个不符合时 , 死锁就不会发生
- 通过加锁顺序处理（线程按照一定的顺序加锁）
- 加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）
- 死锁检测
    
// 死锁的解除
- 资源剥离 , 挂起死锁进程且强制对应资源 , 分配进程
- 撤销进程
- 回退进程

java复制代码> 热锁不算一个物理概念 , 它表示线程在频繁的竞争资源并且资源在频繁的切换\
	- 循环等待 :

JAVA复制代码> 线程有以下状态
    - NEW : 尚未启动的线程的hread状态
    - RUNNABLE : 可运行 , 从虚拟机的角度 , 已经执行 ,但是可能正在等待资源
    - BLOCKED : 阻塞 , 此时等待 monitor锁 , 以读取 synchronized 代码 
    - WAITING : 等待状态 , 处于等待状态的线程正在等待另一个线程执行特定操作
        - wait()
        - join()
        - LockSupport#park()
    - TIMED_WAITING : 指定等待时间的等待
        - Thread.sleep
        - wait(long)
        - join(long)
        - LockSupport#parkNanos
        - LockSupport#parkUntil
    - TERMINATED : 终止线程   
	
// 线程间状态改变的方式	
• 还没起床：sleeping 。
• 起床收拾好了，随时可以坐地铁出发：Runnable 。
• 等地铁来：Waiting 。
• 地铁来了，但要排队上地铁：I/O 阻塞 。
• 上了地铁，发现暂时没座位：synchronized 阻塞。
• 地铁上找到座位：Running 。
• 到达目的地：Dead 。

java复制代码// 节点一 : 你是否发现 , wait 和 notify 是 object 的方法
点开 wait 和 notify 方法就能发现 , 这两个方法是基于 Object 对象的 , 所以我们要理解 ,通知不是通知的线程 ,而是通知的对象
这也就是为什么 , 不要用常量作为通知对象    


// 节点二 : java.lang.IllegalMonitorStateException
当我们 wait/notify 时 , 如果未获取到对应对象的 Monitor , 实际上我们会抛出 IllegalMonitorStateException
所以你先要获得监视器 , 有三种方式 : 
- 通过执行该对象的同步实例方法。
- 通过执行在对象上同步语句体。
- 对于类型为Class的对象，可以执行该类的同步静态方法。    


// 节点三 : 如何进行转换 ? 
Step 1 : 首先看 Object 对象 Native 方法 , bative src 中搜索名字即可

static JNINativeMethod methods[] = {
    {"hashCode",    "()I",                    (void *)&JVM_IHashCode},
    {"wait",        "(J)V",                   (void *)&JVM_MonitorWait},
    {"notify",      "()V",                    (void *)&JVM_MonitorNotify},
    {"notifyAll",   "()V",                    (void *)&JVM_MonitorNotifyAll},
    {"clone",       "()Ljava/lang/Object;",   (void *)&JVM_Clone},
};

//可以看到这里分别调用了 JVM_MonitorWait , JVM_MonitorNotify , JVM_MonitorNotifyAll , 
//从名字就能看到 , 这里是和Monitor 有关的
    
Step 2 : 进入全路径了解 : \openjdk\hotspot\src\share\vm\prims
JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
  JVMWrapper("JVM_MonitorWait");
  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
  JavaThreadInObjectWaitState jtiows(thread, ms != 0);
  if (JvmtiExport::should_post_monitor_wait()) {
    JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);
	// 当前线程已经拥有监视器，并且还没有添加到等待队列中，因此当前线程不能成为后续线程
  }
  ObjectSynchronizer::wait(obj, ms, CHECK);
JVM_END
    
Step 3 :  ObjectSynchronizer::wait(obj, ms, CHECK);
// TODO : 看不懂了呀....先留个坑 
// 总得来说就是 ObjectMonitor通过一个双向链表来保存等待该锁的线程

Step End :  link by @ https://www.jianshu.com/p/a604f1a9f875 
void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
  ...................
   // 创建ObjectWaiter,添加到_WaitSet队列中
   ObjectWaiter node(Self);
   node.TState = ObjectWaiter::TS_WAIT ;
   Self->_ParkEvent->reset() ;
   OrderAccess::fence();          // ST into Event; membar ; LD interrupted-flag

 //WaitSetLock保护等待队列。通常只锁的拥有着才能访问等待队列
   Thread::SpinAcquire (&_WaitSetLock, "WaitSet - add") ;
 //加入等待队列，等待队列是循环双链表
   AddWaiter (&node) ;
   //使用的是一个简单的自旋锁
   Thread::SpinRelease (&_WaitSetLock) ;
   .....................
}

java复制代码// 节点一 : 区别 run 和 start 
run 是通过方法栈直接调用对象的方法 , 而 Start 才是开启线程 , 这一点我们可以从源码中发现 : 
- start 方法是同步的
- start0 是一个 native 方法
- group 是线程组 (ThreadGroup) , 线程可以访问关于它自己线程组的信息
    ?- 线程组主要是为了管理线程 , 将一个大线程分成多个小线程 (盲猜 fork 用到了 , 后面验证一下)
    ?- 线程组也可以通过关闭组来关闭所有的线程
    
public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
}

// Step 1 : Thread.c 结构 -> openjdk\src\native\java\lang
static JNINativeMethod methods[] = {
    {"start0",           "()V",        (void *)&JVM_StartThread},
    {"stop0",            "(" OBJ ")V", (void *)&JVM_StopThread},
    {"isAlive",          "()Z",        (void *)&JVM_IsThreadAlive},
    {"suspend0",         "()V",        (void *)&JVM_SuspendThread},
    {"resume0",          "()V",        (void *)&JVM_ResumeThread},
    {"setPriority0",     "(I)V",       (void *)&JVM_SetThreadPriority},
    {"yield",            "()V",        (void *)&JVM_Yield},
    {"sleep",            "(J)V",       (void *)&JVM_Sleep},
    {"currentThread",    "()" THD,     (void *)&JVM_CurrentThread},
    {"countStackFrames", "()I",        (void *)&JVM_CountStackFrames},
    {"interrupt0",       "()V",        (void *)&JVM_Interrupt},
    {"isInterrupted",    "(Z)Z",       (void *)&JVM_IsInterrupted},
    {"holdsLock",        "(" OBJ ")Z", (void *)&JVM_HoldsLock},
    {"getThreads",        "()[" THD,   (void *)&JVM_GetAllThreads},
    {"dumpThreads",      "([" THD ")[[" STE, (void *)&JVM_DumpThreads},
    {"setNativeName",    "(" STR ")V", (void *)&JVM_SetNativeThreadName},
};

// \openjdk\hotspot\src\share\vm\prims\jvm.cpp
// Step 2 : JVM_StartThread , 翻译了一下 , 大概可以看到那一句 native_thread = new JavaThread(&thread_entry, sz);
// 以及最后的 Thread::start(native_thread);
JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_StartThread");
  JavaThread *native_thread = NULL;

  //由于排序问题，在抛出异常时不能持有Threads_lock。示例:在构造异常时，可能需要获取heap_lock。
  bool throw_illegal_thread_state = false;

  // 我们必须释放Threads_lock才能在Thread::start中post jvmti事件
  {
	// 确保c++ Thread和OSThread结构体在操作之前没有被释放
    MutexLocker mu(Threads_lock);

	//从JDK 5开始threadStatus用于防止重新启动一个已经启动的线程，所以我们通常会发现javthread是null。然而，对于JNI附加的线程，在创建的线程对象(带有javthread集)和更新其线程状态之间有一个小窗口，因此我们必须检查这一点
    if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {
      throw_illegal_thread_state = true;
    } else {
      //我们也可以检查stillborn标志来查看这个线程是否已经停止，但是由于历史原因，我们让线程在开始运行时检测它自己
      jlong size =
             java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));
	  //分配c++线程结构并创建原生线程。
      //从java检索到的堆栈大小是有符号的，但是构造函数接受size_t(无符号类型)，因此避免传递负值，因为这会导致非常大的堆栈。	
      size_t sz = size > 0 ? (size_t) size : 0;
      native_thread = new JavaThread(&thread_entry, sz);
      // 此时可能由于缺少内存而没有为javthread创建osthread。检查这种情况并在必要时抛出异常。
      // 最终，我们可能想要更改这一点，以便只在线程成功创建时才获取锁——然后我们也可以执行这个检查并在javthread构造函数中抛出异常。
      if (native_thread->osthread() != NULL) {
        // 注意:当前线程没有在“prepare”中使用。
        native_thread->prepare(jthread);
      }
    }
  }

  if (throw_illegal_thread_state) {
    THROW(vmSymbols::java_lang_IllegalThreadStateException());
  }

  assert(native_thread != NULL, "Starting null thread?");

  if (native_thread->osthread() == NULL) {
    // No one should hold a reference to the 'native_thread'.
    delete native_thread;
    if (JvmtiExport::should_post_resource_exhausted()) {
      JvmtiExport::post_resource_exhausted(
        JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS,
        "unable to create new native thread");
    }
    THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),
              "unable to create new native thread");
  }

  Thread::start(native_thread);

JVM_END

java复制代码C- Thread
	M- yield() : 可以看到 ,  yield 同样是一个 native 方法
    
// Step 1:  \openjdk\hotspot\src\share\vm\prims\jvm.cpp
// 主要是2句 :  os::sleep(thread, MinSleepInterval, false);
// os::yield();
JVM_ENTRY(void, JVM_Yield(JNIEnv *env, jclass threadClass))
  JVMWrapper("JVM_Yield");
  if (os::dont_yield()) return;
#ifndef USDT2
  HS_DTRACE_PROBE0(hotspot, thread__yield);
#else /* USDT2 */
  HOTSPOT_THREAD_YIELD();
#endif /* USDT2 */
  // 当ConvertYieldToSleep关闭(默认)时，这与传统VM的yield使用相匹配。对于类似的线程行为至关重要
  if (ConvertYieldToSleep) {
    os::sleep(thread, MinSleepInterval, false);
  } else {
    os::yield();
  }
JVM_END
    
    
// TODO : 主要的其实还没有看懂 , 毕竟 C基础有限

java复制代码芋道源码 : http://www.iocoder.cn/JUC/sike/aqs-3/

https://mp.weixin.qq.com/s?__biz=MzIxOTI1NTk5Nw==&mid=2650047475&idx=1&sn=4349ee6ac5e882c536238ed1237e5ba2&chksm=8fde2621b8a9af37df7d0c0a7ef3178d0253abf1e76a682134fce2f2218c93337c7de57835b7&scene=21#wechat_redirect

https://blog.csdn.net/javazejian/article/details/70768369

死磕系列 , 我的多线程导师
http://cmsblogs.com/?cat=151

// JVM 源码 C
https://www.jianshu.com/p/a604f1a9f875