JUC

进程与线程
Synchronized

https://segmentfault.com/a/1190000037600050

进程与线程

进程

正在进行的程序，是系统资源分配的最小单位。有独立的内存空间，但切换开销大

线程

系统任务调度的最小单位，每条线程就是一个任务。由于共享空间，因此需要进行线程间的通信

线程状态： NEW RUNNABLE BLOCKED WAITTING TIMED_WAITTING TERMINATED

TIMED_WAITTING ：等不下去了自己从哪个线程来，回到哪个线程去

sleep 和 wait 区别：

sleep抱着锁睡觉
wait 释放锁

进程通信

管道
报文
socket
信号量（信号）
共享空间

线程通信

lock
信号量
volatile
wait/notify

Synchronized

自动挡的lock
锁住的对象（对象类）

与lock的区别：

synchronized 是关键字 lock是类
synchronized 无法获取锁的状态
synchronized 自动释放 lock 手动释放
synchronized 非公平锁可重入 lock 可调

精准唤醒

Contidion

顺序输出123

package lock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class A {
    public static void main(String[] args) {
        D d = new D();
        new Thread(d::pA).start();
        new Thread(d::pB).start();
        new Thread(d::pC).start();
    }
}
class D {
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();
    public int num = 1;
    public void pA() {
        lock.lock();
        try {
            while (num != 1) {
                c1.await();  //等待
            }
            num = 2;
            System.out.println("A ok");
            System.out.println(Thread.currentThread().getName() + "=> A...");
            c2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void pB() {
        lock.lock();
        try {
            while (num != 2) {
                c2.await();
            }
            num = 3;
            System.out.println("B ok");
            System.out.println(Thread.currentThread().getName() + "=> B...");
            c3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void pC() {
        lock.lock();
        try {
            while (num != 3) {
                c3.await();
            }
            num = 1;
            System.out.println("C ok");
            System.out.println(Thread.currentThread().getName() + "=> C...");
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

并发集合

ConcurrentHashMap
ConcurrentSkipListMap
ConcurrentSkipListSet
CopyOnWriteArrayList
CopyOnWriteArraySet
ArrayBlockingQueue
LinkedBlockingQueue
PriorityBlockingQueue
LinkedBlockingDeque
ConcurrentLinkedQueue

Callable

Runnable 不能返回结果和抛出异常因此出现了Callable

常用辅助类

CountdownLatch

一个线程等多个线程完成后再继续

CyclicBarrier
多个线程互相等待，直到到达同一个同步点，再继续一起执行

Semaphore
多个共享资源互斥的使用

读写锁

读锁共享锁
写锁独享锁

阻塞队列

四组API

线程池

四大方法 single fixed cache schedule
七大参数 coresize maxcoresize 阻塞队列拒绝策略时间时间单位线程工厂
四种拒绝策略
- 1.new ThreadPoolExecutor.AbortPolicy() 线程池不够用了，还有任务，就抛出异常
- 2.new ThreadPoolExecutor.CallerRunsPolicy() 哪来的哪去
- 3.new ThreadPoolExecutor.DiscardPolicy() 队列满了，丢掉任务，不会抛出异常
- 4.new ThreadPoolExecutor.DiscardOldestPolicy() 队列满了，尝试和最早的竞争，也不会抛出异常

函数式接口

只有一个方法的接口

Supply Consumer Function Predicted

Stream计算

分支合并ForkJoin

任务窃取

JMM内存模型

volatile

提供轻量级的同步机制
加入内存屏障所用的关键字。cpu不知道何时加入。

可见性 volatile 将数据刷入主存
有序性禁止指令重排
非原子

原子类

不用lock synchronized 怎么保证原子

指令重排

jvm的指令重排
cpu指令的指令重排
内存级别的指令重排（指令重排的原因是因为在cpu和缓存中引入了storebuffer）

CAS

比较工作内存和主内存中的值是否一样一样就执行不一样就循环

缺点：

耗时
aba

原子引用

+版本号