JUC

1、什么是JUC？

java.util工具包、包、分类

2、线程和进程

进程：一个程序，如，QQ.exe Music.exe 程序的集合
一个进程往往可以包含多个线程，至少包含一个
Java默认有几个进程？2个—> main线程、GC线程
对于Java而言：Thread、Runnable、Callable
Java真的可以开启线程吗？开不了

并发编程：并发、并行
并发（多线程操作同一个资源）
CPU一核，模拟出来多条线程，天下武功，唯快不破，快速交替
并行（多个人一起行走）
CPU多核，多个线程可以同时执行，线程池

public class Test1 {
    public static void main(String[] args) {
    	//获取CPU的核数
    	//CPU密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用CPU资源
线程的状态：6个

public enum State {
		//新生（创建）
        NEW,
		//运行
        RUNNABLE,
		//阻塞
        BLOCKED,
		//等待（死死地等）
        WAITING,
		//超时等待
        TIMED_WAITING,
		//终止
        TERMINATED;
    }

wait和sleep的区别？
1、来自不同的类
wait来自Object
sleep来自Thread
2、关于锁的释放
wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放
3、使用的范围不同
wait
必须在同步代码块中
sleep
可以在任何地方睡
4、是否需要捕获异常
wait不需要捕获异常
sleep必须捕获异常

3、Lock锁（重点）

//卖票的例子

//真正的多线程开发
//线程就是一个单独的资源类，没有任何附属的操作

public class Test1 {

    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"C").start();

    }
}
//资源类  OOP
class Ticket{
    //属性  方法
    private int number = 50;
    //卖票的方式
    public synchronized void sale(){
        if(number > 0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余："+number);
        }
    }
}

//卖票的例子

//真正的多线程开发
//线程就是一个单独的资源类，没有任何附属的操作

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test02 {

    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
        new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"A").start();
        new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"B").start();
        new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"C").start();

    }
}
//Lock三部曲
//1、Lock lock = new ReentrantLock();
//2、lock.lock(); //加锁
//3、finally------>lock.unlock();


//资源类  OOP
class Ticket2{
    //属性  方法
    private int number = 50;
	//创建锁
    Lock lock = new ReentrantLock();
    
    //卖票的方式
    public synchronized void sale(){
        lock.lock();//加锁

        try {
            //业务代码
            if(number > 0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余："+number);
            }
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

Synchronized 和Lock的区别？

1、Synchronized 内置的java关键字，Lock是一个java类

2、Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁

3、Synchronized 会自动释放锁，Lock必须手动释放锁，如果不释放锁，会产生死锁

4、Synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等下去

5、Synchronized 可重入锁，不可中断的，非公平；Lock，可重入锁，可以判断锁，非公平（可以自己设置）

6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码

锁是什么？如何判断锁的是谁？

4、生产者消费者问题

面试问题：单例模式，排序算法，生产者消费者，死锁

业务：判断等待，执行，通知

两个线程的生产者消费者问题

//生产者消费者问题实现加一减一操作
public class A {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }

}
class Data{
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
    	//业务：判断等待，执行，通知
        if(number != 0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"->"+number);
        //通知其他线程，+1完毕了
        this.notifyAll();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
    //业务：判断等待，执行，通知
        if(number == 0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"->"+number);
        //通知其他线程，-1完毕了
        this.notifyAll();
    }
}

新的问题：4个线程，ABCD怎么解决？

如果是4个线程的话就会出现问题，因为if()只判断一次，可能两个线程都进去了，就不会等待，解决方案就是把if()改为while(),就会循环等待，一个线程A拿到了锁，另一个线程C等待，B拿到锁了，D等待

//将if()判断语句改为while()

public class A {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }

}
class Data{
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while(number != 0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"->"+number);
        //通知其他线程，+1完毕了
        this.notifyAll();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
        while(number == 0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"->"+number);
        //通知其他线程，-1完毕了
        this.notifyAll();
    }
}

JUC版的生产者消费者问题，使用condition监视器实现


代码实现

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class Data2{
    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
//    condition.await();//等待
//    condition.signalAll();//唤醒全部

    //+1
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while(number != 0){
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"->"+number);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    //-1
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while(number == 0){
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"->"+number);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

Condition监视器实现精准通知线程执行:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();
    }
}
class Data3{
    public int number = 1;
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void printA(){
        lock.lock();
        try {
            while(number != 1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"->AAAAAA");
            number = 2;
            //唤醒指定的人，B
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB() {
        lock.lock();
        try {
            while(number != 2){
                    condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"->BBBBBB");
            number = 3;
            //唤醒指定的人，C
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC() {
        lock.lock();
        try {
            while(number != 3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"->BBBBBB");
            number = 1;
            //唤醒指定的人，C
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

5、8锁现象

锁是什么？如何判断锁的是谁？
对象、Class
Test01.java

/**
 * 8锁，就是关于锁的8个问题
 * 1、标准情况下，两个线程先打印   发短信  还是  打电话
 * 1、sendSms延迟4秒，两个线程先打印 发短信  是  打电话？
 */

import java.util.concurrent.TimeUnit;

public class Test01 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"A").start();
    }

}

class Phone{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁先执行
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

Test02.java

/**
 * 3、增加了一个普通方法，先执行发短信还是hello？  普通方法
 * 4、两个对象，两个同步方法，先执行发短信还是打电话
 */

import java.util.concurrent.TimeUnit;

public class Test02 {
    public static void main(String[] args) {
        //两个对象,两个调用者，两把锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone2{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁先执行
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    //这里没有锁，不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

Test03.java

import java.util.concurrent.TimeUnit;

/**
 * 5、增加两个静态的同步方法,先打印发短信还是打电话
 * 两个方法是同一个锁，锁的是Class
 */
public class Test3 {
    public static void main(String[] args) {
        //两个对象的类模板只有一个，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone3{
    //synchronized 锁的对象是方法的调用者
    //static 静态方法，类一加载，就有了，锁的是Class模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
    //这里没有锁，不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

Test04.java

/**
 * 1、1个静态的同步方法，1个普通同步方法，1个对象
 * 1、1个静态的同步方法，1个普通同步方法，2个对象，先打印哪个？
 */

import java.util.concurrent.TimeUnit;

public class Test04 {
    public static void main(String[] args) {
        //两个对象的类模板只有一个，锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }

}

class Phone4{
    //static 静态方法，类一加载，就有了，锁的是Class模板
    //静态同步方法，锁的是Class模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    //普通同步方法，锁的是调用者
    public synchronized void call(){
        System.out.println("打电话");
    }
}

Set不安全

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

//1、Set<String> set = Collections.synchronizedSet(new HashSet<>());
//2、
public class SetTest {
    public static void main(String[] args) {
       
// Set<String> set = new HashSet<>();//java.util.ConcurrentModificationException并发修改异常
//        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet<>();

        for (int i = 1; i <= 30 ; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

HashSet底层是什么？

public HashSet() {
    map = new HashMap<>();
}
//add set 本质就是map key   是无法重复的
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
private static final Object PRESENT = new Object();//不变的值

Map不安全

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
//  java.util.ConcurrentModificationException  并发修改异常
public class MapTest {
    public static void main(String[] args) {
        //map是这样用的吗？ 不是，在工作中不用HashMap
        //默认等价于什么？ new HashMap<>(16, 0.75);
        //Map<String, String> map = new HashMap<>();
        Map<String, String> map = new ConcurrentHashMap<>();
        for (int i = 1; i < 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            }).start();
        }
    }
}

ConcurrentHashMap底层原理？

Callable

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new Thread().start();//怎么启动？？
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask<V>()).start();
        //new Thread(new FutureTask<V>( Callable )).start();
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);//适配类

        new Thread(futureTask,"A").start();

        Integer o = (Integer) futureTask.get();
        System.out.println(o);
    }
}
class MyThread implements Callable<Integer>{
    @Override
    public Integer call() {
        System.out.println("call()");
        return 1024;
    }
}

两个线程，会打印几个call()???

答案：1个，结果会被缓存

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new Thread().start();//怎么启动？？
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask<V>()).start();
        //new Thread(new FutureTask<V>( Callable )).start();
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);//适配类

        new Thread(futureTask,"A").start();//两个线程，会打印几个call()
        new Thread(futureTask,"B").start();//结果会被缓存

        Integer o = (Integer) futureTask.get();//这个get方法可能会产生阻塞，把他放到最后
        //或者使用异步通信来处理
        System.out.println(o);
    }
}
class MyThread implements Callable<Integer>{
    @Override
    public Integer call() {
        System.out.println("call()");//会打印几个call()
        return 1024;
    }
}

8、常用的辅助类

8.1、CountDownLatch(减法计数器)

import java.util.concurrent.CountDownLatch;
//减法计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //总数是6，必须要执行任务的时候，再使用！
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; 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");
    }
}

原理：

countDownLatch.countDown();//数量减1

countDownLatch.await();//等待计数器归零，然后向下执行

每次有线程调用countDown()数量减1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行！

8.2、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 tmp = i;//lambda拿不到i,需要final修饰的中间变量
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+tmp+"个龙珠");
                try {
                    cyclicBarrier.await();//等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

8.3、Semaphore

import java.util.concurrent.Semaphore;

public class SemphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                try {
                    // acquire() 得到
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    // release() 释放
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

原理：

semphore.acquire()，获得，假设如果已经满了，等待，等待被释放为止

semphore.release()，释放，会将当前的信号量释放+1，然后唤醒等待的线程

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

9、ReadWriteLock

//独占锁（写锁）一次只能被一个线程占有
//共享锁（读锁）多个线程可以同时占有

import java.io.ObjectInputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
//独占锁（写锁）一次只能被一个线程占有
//共享锁（读锁）多个线程可以同时占有
//ReadWriteLoack
//读-读    可以共存
//读-写    不能共存
//写-写	 不能共存
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();

        for (int i = 1; i <= 5; i++) {
            final int tmp = i;
            new Thread(()->{
                myCache.put(tmp+"", tmp+"");
            },String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            final int tmp = i;
            new Thread(()->{
                myCache.get(tmp+"");
            },String.valueOf(i)).start();
        }
    }
}
//加锁的
class MyCacheLock{
    private volatile Map<String, Object> map = new HashMap<>();
    //读写锁：更加细粒度的控制
    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();
        }
    }
}

//自定义缓存
//没加锁的
class MyCache{
    private volatile Map<String, Object> map = new HashMap<>();

    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");
    }
}

10、阻塞队列

什么情况下我们会使用阻塞队列：多线程并发处理，线程池！
学会使用队列：添加元素，删除元素

四组API：

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

public class TestBlockingQueue {
    public static void main(String[] args) throws InterruptedException {
        test4();
    }
    public static void test1(){
        //队列大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        System.out.println("---------------------------");
        // java.lang.IllegalStateException: Queue full    抛出队列满的异常
        // System.out.println(blockingQueue.add("d"));
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        // java.util.NoSuchElementException         抛出异常
        // System.out.println(blockingQueue.remove());
    }
    public static void test2(){
        //队列大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));

        System.out.println(blockingQueue.offer("d"));//不抛出异常

        System.out.println("---------------------------");

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());

        System.out.println(blockingQueue.poll());   //不抛出异常
    }
    //等待，阻塞（一直阻塞）
    public static void test3() throws InterruptedException {
        //队列大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        //队列没有位置了，一直阻塞
        // blockingQueue.put("d");

        System.out.println("---------------------------");

        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        //队列没有元素了，一直阻塞
        System.out.println(blockingQueue.take());
    }
    //等待，阻塞（超时等待）
    public static void test4() throws InterruptedException {
        //队列大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("a", 2, TimeUnit.SECONDS));

        //队列没有位置了，一直阻塞

        System.out.println("---------------------------");

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS));
    }
}

SynchronousQueue同步队列

没有容量，进去一个元素，必须等待取出来之后，才能再往里面放一个元素

put、take

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * 同步队列
 * 和其他的BlockingQueue不一样，SynchronousQueue 不存储元素
 * put了一个元素，必须从里面先take取出来，否则不能put进去值
 */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue blockingQueue = new SynchronousQueue();

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+" put 1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName()+" put 2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName()+" put 3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1").start();
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"->"+ blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"->"+ blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"->"+ blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2").start();
    }
}

11、线程池（三大方法，七大参数，四个拒绝策略）

线程池：

池化技术

程序的运行，本质：占用系统资源！优化资源的使用----->池化技术

线程池、连接池、内存池、对象池。。。。创建，销毁，十分浪费资源

池化技术：事先准备好的一些资源，有人要用，就来我这里拿，用完之后还给我

线程池的好处：

1、降低资源的消耗

2、提高响应速度

3、方便管理

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//Executors 工具类、3大方法
public class Demo01 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程的线程池
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);//创建一个固定大小的线程池
//        ExecutorService threadPool =  Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱

        try {
            for (int i = 0; i < 100; i++) {
                //使用了线程池之后，使用线程池进行创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" OK");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池结束，程序结束，关闭线程池
            threadPool.shutdown();
            //放到finally块，保证一定结束
        }
    }
}

源码分析：(3种方法核心底层还是ThreadPoolExecutor)

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

//ThreadPoolExecutor()        这里就牵扯到7大参数，4种拒绝策略了

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

线程池（模拟银行办理业务）****（7大参数，4种拒绝策略）


(模拟去银行办理业务，银行只开放2个窗口（①corePoolSize），总共5个窗口(②maximumPoolSize)，其余3个（前两个窗口在营业，后3个在等待，这里的就是等待时间③keepAliveTime）不开，等待时间单位（④TimeUnit.SECONDS）来人了暂时去候客区（Deque阻塞队列，这里候客区3个座位，⑤new LinkedBlockingDeque<>(3)），如果人多了，比如来第6个以上人了，就开放一个窗口，银行最多容纳8个人（Deque + max），第六个参数是创建线程的工厂方法（默认为⑥Executors.defaultThreadFactory()），
如果再来人的话就有四种拒绝策略⑦new ThreadPoolExecutor.CallerRunsPolicy()）

import java.util.concurrent.*;

/**
 * 4种拒绝策略
 * new ThreadPoolExecutor.AbortPolicy()//拒绝策略，满了的话直接抛出异常java.util.concurrent.RejectedExecutionException
 * new ThreadPoolExecutor.CallerRunsPolicy()//拒绝策略（满了的话就说我这人满了，你要办理你们公司的，去你们公司办理，哪来的回哪去）
 * new ThreadPoolExecutor.DiscardPolicy()//拒绝策略（从阻塞队列丢弃最新的任务（队尾），不会抛出异常）
 * new ThreadPoolExecutor.DiscardOldestPolicy()//拒绝策略（从阻塞队列丢弃最旧的任务（队首），不会抛出异常）
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        //7大参数
		/**
         * 了解：IO密集型、CPU密集型（调优）
         * 最大线程到底该如何定义
         * 1、CPU密集型，电脑是几核CPU，就可以定义为几，可以保持CPU的效率
         * 获取方式:       Runtime.getRuntime().availableProcessors()
         * 2、IO密集型  判断程序中十分消耗IO的线程有几个，比如15个，那就可以定义为它的两倍，30个
         */

        ExecutorService threadPool = new ThreadPoolExecutor(
                2,            //核心池大小（银行开放2个窗口）
                5,       //最大池的大小（银行最多开放5个窗口）CPU密集型定义：Runtime.getRuntime().availableProcessors()
                3,          //存活时间 （比如前两个窗口在营业，后3个在等待，这里的就是等待时间）
                TimeUnit.SECONDS,          //等待的时间单位
                new LinkedBlockingDeque<>(3),//阻塞队列（模拟银行的候客区，有3个座位）
                Executors.defaultThreadFactory(),//线程池创建Thread线程的工厂类。没有提供的话，就使用线程池内部默认的创建线程的方式
                new ThreadPoolExecutor.CallerRunsPolicy()//拒绝策略（从阻塞队列丢弃最旧的任务（队首），不会抛出异常）
        );

        try {
            //最大承载;Deque(阻塞队列--候客区椅子座位数，这里是3) + max（最大池大小---最多开放的窗口，这里是5）
            //超过RejectedExecutionException
            for (int i = 1; i <= 9; i++) {  //这里可以从1-9逐个测试不同的拒绝策略会怎么样
                final int tmp = i;
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+ " OK");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadPool.shutdown();
        }
    }
}

池的大小如何去设置？
了解：CPU密集型、IO密集型（调优）
面试问你创建多少个线程，该如何回答
最大线程到底该如何定义
1、CPU密集型，电脑是几核CPU，就可以定义为几，在这基础上+1，可以保持CPU的效率
获取方式: Runtime.getRuntime().availableProcessors()
2、IO密集型 判断程序中十分消耗IO的线程有几个（N），比如15个，那就可以定义为它的两倍再多一个（2N+1）个

12、四大函数式接口（必会）

泛型、枚举、反射
新时代的程序猿：lambda表达式、链式编程、函数式接口、Stream流式计算

函数式接口的作用：简化编程模型

import java.util.function.Function;
/**
 * Function  函数式接口，有一个输入参数，有一个输出参数
 */
public class Demo01 {
    public static void main(String[] args) {
//        Function function = new Function<String, String>() {
//            @Override
//            public String apply(String str) {
//                return str;
//            }
//        };

        //写成lambda表达式：
        Function function = (str)->{return str;};
        System.out.println(function.apply("abcd"));
    }
}

import java.util.function.Predicate;
/**
 * 断定型接口：有一个输入参数，返回值只能是布尔值
 */
public class Demo02 {
    public static void main(String[] args) {
//        Predicate<String> predicate = new Predicate<String>() {
//            @Override
//            public boolean test(String str) {
//                return str.isEmpty();
//            }
//        };
        //写成lambda表达式：
        Predicate<String> predicate = (str)->{return str.isEmpty();};

        System.out.println(predicate.test("abcd"));
    }
}

import java.util.function.Consumer;

/**
 * 消费型接口：没有返回值，只有一个参数
 */
public class Demo03 {
    public static void main(String[] args) {
//        Consumer<String> consumer = new Consumer<String>() {
//            @Override
//            public void accept(String str) {
//                System.out.println(str);
//            }
//        };

        //lambda表达式
        Consumer<String> consumer = (str)->{System.out.println(str);};
        consumer.accept("abcd");
    }
}

import java.util.function.Supplier;
/**
 * 供给型接口：只有一个返回值，没有参数
 */
public class Demo04 {
    public static void main(String[] args) {
//        Supplier<Integer> supplier = new Supplier<Integer>() {
//            @Override
//            public Integer get() {
//                System.out.println("abcd");
//                return 1024;
//            }
//        };
        
        Supplier<Integer> supplier = ()->{return 1024;};

        System.out.println(supplier.get());
    }
}

13、Stream流式计算

什么是Stream流式计算？

大数据：存储+计算

集合、MySQL本质就是存储东西的；

计算都应该交给流来操作

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}

import javax.print.DocFlavor;
import java.util.Arrays;
import java.util.List;

/**
 * 题目要求：一分钟内完成此题，只用一行代码
 * 现在有5个用户，筛选：
 * 1、ID必须是偶数
 * 2、年龄必须大于23
 * 3、用户名转为大写字母
 * 4、用户名字母到这排序
 * 5、只输出一个用户
 */
public class Test {
    public static void main(String[] args) {
        User u1 = new User(1, "a", 21);
        User u2 = new User(2, "b", 22);
        User u3 = new User(3, "c", 23);
        User u4 = new User(4, "d", 24);
        User u5 = new User(6, "e", 25);
        //集合就是存储
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);
        //计算交给Stream流
        list.stream()
                .filter(u->{return u.getId()%2 == 0;})
                .filter(u->{return u.getAge() > 23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((uu1, uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

14、ForkJoin

ForkJoin的特点：工作窃取

这里面维护的都是双端队列

import java.util.concurrent.RecursiveTask;

/**
 * 求和计算的任务
 * 3000     6000（ForkJoin）     10000（Stream并行流）
 * 如何使用ForkJoin
 * 1、forkJoinPool  通过它来执行
 * 2、计算任务 forkJoinPool.execute(ForkJoinTask task)
 * 3、计算类要继承ForkJoinTask
 */
public class ForkJoinDemo extends RecursiveTask<Long> {
    private Long start;  //1
    private Long end;    //100000000000

    //临界值
    private Long tmp = 10000L;

    public ForkJoinDemo(Long start, Long end){
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if((end - start) < tmp){
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }else{       //forkJoin递归
            long middle = (start + end) / 2;  //中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork();//拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle + 1, end);
            task2.fork();//拆分任务，把任务压入线程队列

            return task1.join() + task2.join();
        }
    }
}

测试：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        test1();
//        test2();
        test3();
    }
    //普通程序猿
    public static void test1(){
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"Time:"+(end - start));
    }

    //使用ForkJoin的牛逼程序猿
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交任务
        Long sum = submit.get();

        long end = System.currentTimeMillis();

        System.out.println("sum="+sum+"Time:"+(end - start));
    }

    //顶级大佬程序猿
    public static void test3(){
        long start = System.currentTimeMillis();
        //Stream并行流   (]
        long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0,Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"Time:"+(end - start));
    }
}

15、异步回调

与同步相对，异步回调不会影响主线程，不用阻塞等待当前线程，提高效率，和Ajax很像

package com.fang.future;/*
 * @Program:untitled
 * @Description:description
 * @Author:Pufang
 * @Time:2020-06-24 12-22-33
 **/

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * 异步调用： CompletableFuture
 * // 异步执行
 * // 成功回调
 * // 失败回调
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 没有返回值的 runAsync 异步回调
//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
//            try {
//                TimeUnit.SECONDS.sleep(2);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"runAsync=>Void");
//        });
//
//        System.out.println("1111");
//
//        completableFuture.get(); // 获取阻塞执行结果

        // 有返回值的 supplyAsync 异步回调
        // ajax，成功和失败的回调
        // 返回的是错误信息；
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            int i = 10/0;
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t=>" + t); // 正常的返回结果
            System.out.println("u=>" + u); // 错误信息：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233; // 可以获取到错误的返回结果
        }).get());

        /**
         * succee Code 200
         * error Code 404 500
         */
    }
}

16、JMM

JMM即为JAVA 内存模型（java memory model）。
JMM规定了内存主要划分为主内存和工作内存两种。

关于JMM的一些同步约定：
1、线程解锁前，必须把共享变量立刻刷回主存
2、线程加锁前，必须读取主存中的最新值到工作内存中！
3、加锁和解锁是同一把锁
线程 工作内存、主内存
8种操作


JVM在设计时候考虑到，如果JAVA线程每次读取和写入变量都直接操作主内存，对性能影响比较大，所以每条线程拥有各自的工作内存，工作内存中的变量是主内存中的一份拷贝，线程对变量的读取和写入，直接在工作内存中操作，而不能直接去操作主内存中的变量。但是这样就会出现一个问题，当一个线程修改了自己工作内存中变量，对其他线程是不可见的，会导致线程不安全的问题。因为JMM制定了一套标准来保证开发者在编写多线程程序的时候，能够控制什么时候内存会被同步给其他线程。

内存交互操作
　　内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中
　　JMM对这八种指令的使用，制定了如下规则：

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
对一个变量进行unlock操作之前，必须把此变量同步回主内存

17、volatile

volatile是Java虚拟机提供轻量级的同步机制
1、保证可见性
为了提高效率，JVM在执行过程中，会尽可能的将数据在工作内存中执行，但这样会造成一个问题，共享变量在多线程之间不能及时看到改变，这个就是可见性问题
2、不保证原子性
3、禁止指令重排序

import java.util.concurrent.TimeUnit;
public class JMMDemo {

    //不加volatile 程序就会死循环
    //加volatile 可以保证可见性
    private volatile static int num = 0;
    public static void main(String[] args) {

        new Thread(()->{//线程1对主内存的变化是不知道的
            while(num == 0){

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);
    }
}

2、不保证原子性
原子性 : 不可分割
线程A在执行任务的时候，不能被打扰，也不能被分割。要么同时成功，要么同时失败。

public class VolatileDemo02 {
    //volatile不保证原子性
    private volatile static int num = 0;
    public static void add(){
        num++;
    }
    public static void main(String[] args) {
        //理论上num结果应该为2万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while(Thread.activeCount() > 2){ //main线程 gc线程
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

使用原子类，解决原子性问题

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileDemo02 {
    //volatile不保证原子性

    //原子类的Integer
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
//        num++;   //不是原子性的操作
        num.getAndIncrement();  // AtomicInteger + 1 方法，CAS
    }

    public static void main(String[] args) {
        //理论上num结果应该为2万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount() > 2){ //main线程 gc线程
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

3、禁止指令重排序
一段代码是这样的：

1. 去前台取下 U 盘
2. 去教室写 10 分钟作业
3. 去前台取下快递

代码有其执行顺序，在单线程情况下，JVM、CPU指令集会对其进行优化重排序，比如，按 1->3->2的方式执行，也是没问题，可以少跑一次前台，这种叫做指令重排序。

但在多线程场景下就有问题了，什么问题呢。可能快递是在你写作业的10分钟内被另一个线程放过来的，或者被人变过了，如果指令重排序了，代码就会是错误的

volatile可以避免指令重排
内存屏障。CPU指令。作用：
1、保证特定的操作执行顺序
2、可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）

volatile是可以保证可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象

18、单例模式

单例模式（Singleton Pattern）是Java中最简单的设计模式，是一种创建型模式，它提供了一种创建对象的最佳方式，这种模式涉及到一个单一的类来创建对象，同时确保只有一个对象被创建。这个类提供了访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。
注意：
1、单例类只能有一个实例对象
2、单例类必须自己创建自己的唯一实例
3、单例类必须给其他对象提供该实例
饿汉式
线程安全，比较常用，但容易产生垃圾，因为一开始就初始化，没有加锁，执行效率会提高。

public class Singleton{
	private static Singleton singleton = new Singleton();
	private Singleton(){}
	public static Singleton getInstance(){
		return singleton;
	}
}

懒汉式（单线程）
第一次调用，才初始化，避免浪费内存
线程不安全，延迟初始化，没有加锁，在多线程不能正常工作

public class Singleton{
	private static Singleton singleton;
	private Singleton(){}
	public static Singleton getInstance(){
		if(singleton == null){
			singleton = new Singleton();
		}
		return singleton;
	}
}

懒汉式（多线程下）
第一次调用，才初始化，避免浪费内存
必须加锁 synchronized 才能保证线程安全，但加锁会影响效率

public class Singleton{
	private static Singleton singleton;
	private Singleton(){}
	public static synchronized Singleton getInstance(){
		if(singleton == null){
			singleton = new Singleton();
		}
		return singleton;
	}
}

双重校验锁 DCL（Double Check Locking）多线程安全
双重校验锁写法保证线程安全
使用volatile：保证可见性，禁止指令重排序
线程安全，延迟初始化。这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

public class Singleton{
	private volatile static Singleton singleton;

	private Singleton(){}

	public static Singleton getInstance(){
		if(singleton == null){
			Synchronized(Singleton.class){
			//Synchronized保证了原子性
				if(singleton == null){
					//new对象分解三条指令：前两个指令是new,第三个是 = 
					//1、分配内存空间
					//2、初始化对象
					//3、赋值给变量
					singleton = new Singleton();
				}
			}
		}
	}
}

19、深入理解CAS

CAS:比较并交换，比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作，如果不是就一直循环
CAS实现原子操作的三大问题：
1、ABA问题
2、循环时间长开销大
3、只能保证一个共享变量的原子操作

20、原子引用解决ABA问题

21、各种锁的理解