并发编程、JUC、面试经典、线程池、Synchronized锁升级原理（偏向锁、轻量级锁、重量级锁、锁自旋、锁消除），ReentrantLock 锁介绍

目录

一、多线程的相关知识

栈与栈帧

线程上下文切换

简单了解多线程

进程和线程的区别

线程状态介绍

二、创建线程的几种方式

继承Thread类

实现Runnable接口

实现callable接口

三种创建方式的区别

三、多线程的常见方法

start和run

优先级Priority

守护线程Daemon

sleep

yield

join

park，unpark

interrupt

wait、notify

wait和sleep的区别

四、线程安全问题

成员变量和静态变量是否线程安全？

局部变量是否线程安全？

常见的现场安全类有哪些

线程不安全场景分析（卖票问题）：

synchronized解决线程不安全问题（必须使用同一把锁）

多线程下的时间日期格式化问题

Lock锁解决线程不安全问题

死锁现象

活锁现象

饥饿锁

不可见问题（线程之间不能读取最新的共享数据）

原子性问题

LongAdder

五、模式应用

应用一：等待（wait）唤醒（notify）方法

应用搜索二：阻塞队列BlockingQueue

六、线程池相关

线程池存在的意义：

Executors默认线程池

ThreadPoolExecutor线程池

任务调度

如何处理线程池中的线程执行任务过程中的异常？

七、线程安全类

Atomic包

Hashtable

ConcurrentHashMap

 BlockingQueue

 CountDownLatch

CyclicBarrier

 Semaphore

八、几种锁的介绍

Synchronized

前置知识：Monitor

synchronized---轻量级锁

synchronized---锁膨胀

 synchronized---自旋优化

synchronized---偏向锁

ReentrantLock 

stampedLock

---

一、多线程的相关知识

栈与栈帧

我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟 机就会为其分配一块栈内存。 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

线程上下文切换

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

• 线程的 cpu 时间片用完
• 垃圾回收
• 有更高优先级的线程需要运行
• 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch（上下文切换） 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念 就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等 Context Switch 频繁发生会影响性能

简单了解多线程

• 是指从软件或者硬件上实现多个线程并发执行的技术。 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个
• 并行：在同一时刻，有多个指令在多个CPU上同时执行。
• 并发：在同一时刻，有多个单个CPU上交替执行。

进程和线程的区别

• 进程：是正在运行的程序

1. 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
2. 动态性：进程的实质程序的一次执行过程，进程是动态产生，动态消亡的
3. 并发性：任何进程都可以同其他进程一起并发执行

• 线程：是进程中的单个顺序控制流，是一条执行路径

1. 单线程：一个进程如果只有一条执行路径，则称为单线程程序
2. 多线程：一个进程如果有多条执行路径，则称为多线程程序

线程状态介绍

•  当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程状态被定义在了java.lang.Thread.State枚举类中

State枚举类的源码如下：

public class Thread {
    
    public enum State {
    
        /* 新建 */
        NEW , 
​
        /* 可运行状态 */
        RUNNABLE , 
​
        /* 阻塞状态 */
        BLOCKED , 
​
        /* 无限等待状态 */
        WAITING , 
​
        /* 计时等待 */
        TIMED_WAITING , 
​
        /* 终止 */
        TERMINATED;
    
    }
    
    // 获取当前线程的状态
    public State getState() {
        return jdk.internal.misc.VM.toThreadState(threadStatus);
    }
    
}

通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下

线程状态	具体含义
NEW	一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE	当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING	一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING	一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED	一个完全运行完成的线程的状态。也称之为终止状态、结束状态

各个状态的转换，如下图所示：

情况 1 NEW --> RUNNABLE

当调用 t.start() 方法时，由 NEW --> RUNNABLE

情况 2 RUNNABLE <--> WAITING

t 线程 用 synchronized(obj) 获取了对象锁后 调用 obj.wait() 方法时， t 线程 从 RUNNABLE -- > WAITING ，调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时 竞争锁成功，t 线程 从WAITING -- >RUNNABLE ，竞争锁失败，t 线程 从WAITING -- > BLOCKED

情况 3 RUNNABLE <--> WAITING

当前线程 调用 t.join() 方法时， 当前线程 从 RUNNABLE -- > WAITING ，注意是当前线程 在 t 线程对象 的监视器上等待 t 线程 运行结束，或调用了 当前线程 的 interrupt() 时， 当前线程 从 WAITING -- > RUNNABLE

情况 4 RUNNABLE <--> WAITING

当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE -- > WAITING 调用 LockSupport.unpark( 目标线程 ) 或调用了线程 的 interrupt() ，会让目标线程从 WAITING -- >

RUNNABLE

情况 5 RUNNABLE <--> TIMED_WAITING

t 线程 用 synchronized(obj) 获取了对象锁后 调用 obj.wait(long n) 方法时，t 线程 从 RUNNABLE -- > TIMED_WAITING ， t 线程 等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时 ，竞争锁成功，t 线程 从TIMED_WAITING -- > RUNNABLE ，竞争锁失败，t 线程 从

TIMED_WAITING -- > BLOCKED

情况 6 RUNNABLE <--> TIMED_WAITING

当前线程 调用 t.join(long n) 方法时， 当前线程 从 RUNNABLE -- > TIMED_WAITING

注意是 当前线程 在 t 线程对象 的监视器上等待 ，当前线程等待时间超过了 n 毫秒，或 t 线程 运行结束，或调用了 当前线程 的 interrupt() 时， 当前线程 从 TIMED_WAITING -- > RUNNABLE

情况 7 RUNNABLE <--> TIMED_WAITING

当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE -- > TIMED_WAITING

当前线程 等待时间超过了 n 毫秒， 当前线程 从 TIMED_WAITING -- > RUNNABLE

情况 8 RUNNABLE <--> TIMED_WAITING

当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时， 当前线 程从 RUNNABLE -- > TIMED_WAITING ，调用 LockSupport.unpark(目标线程 ) 或调用了线程 的 interrupt() ，或是等待超时，会让目标线程从 TIMED_WAITING-- > RUNNABLE

情况 9 RUNNABLE <--> BLOCKED

t 线程 用 synchronized(obj) 获取了对象锁时如果竞争失败，从RUNNABLE -- > BLOCKED

持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED的线程重新竞争，如果其中 t 线程 竞争 成功，从 BLOCKED -- > RUNNABLE ，其它失败的线程仍然 BLOCKED

情况 10 RUNNABLE <--> TERMINATED

当前线程所有代码运行完毕，进入 TERMINATED

二、创建线程的几种方式

继承Thread类

方法介绍：

实现步骤：

1. 定义一个类（MyThread），继承Thread类
2. 在MyThread类中实现run()重写
3. 创建MyThread类对象
4. 启动线程，调用start()放法

代码实现：

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
​
        my1.start();
        my2.start();
    }
}

实现Runnable接口

实现步骤：

1. 定义一个类（MyRunnable），实现Runnable接口
2. 在MyRunnable类中重写run()方法
3. 创建MyRunnable类对象
4. 创建Thread对象，将创建的MyRunnable类作为Thread对象构造方法的参数传入
5. 调用Thread对象的start()方法

代码实现：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();
​
        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
        //Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"坦克");
        Thread t2 = new Thread(my,"飞机");
​
        //启动线程
        t1.start();
        t2.start();
    }
}

实现callable接口

方法介绍：

实现步骤：

1. 创建一个类(MyCallable)实现Callable接口
2. 重写Callable中的call()方法
3. 创建MyCallable对象
4. 创建Future实现类FutureTask对象，把Mycallable作为构造方法的参数
5. 创建Thread对象，把FutureTask作为构造方法的参数
6. 启动Thread线程，调用start()方法
7. 调用FutureTask的get()方法，获取Mycallable的返回值，get方法会一直等待线程执行完获取结果，必须要放在start后面，否则会一直等待

代码实现：

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();
​
        //Thread t1 = new Thread(mc);
​
        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);
​
        //创建线程对象
        Thread t1 = new Thread(ft);
        //开启线程
        t1.start();
​
        String s = ft.get();//该方法会一直等到线程执行完获取返回值，否则会一直等待，所以要放在start方法后面
        System.out.println(s);
    }
}

三种创建方式的区别

实现Runnable、Callable接口的的优点：

• 好处：扩展性强，实现该接口的同时，还可以继承其他类
• 缺点：编程相对复杂，不能直接调用Thread类方法

继承Thread类：

• 好处：编程相对简单，可以直接调用Thread类方法
• 缺点：可以拓展性较差，不能再继承其他类

Runnable和Callable的区别：

• Runnable规定的方法是run(),Callable规定的方法
• Runnable的run()方法不能抛出异常，而Callable的call()方法可以抛出异常
• Runnable执行完毕后没有返回值，而Callable执行完毕后有返回值
• Callable可与通过Future的实现类FutureTask的get()方法计算返回值

三、多线程的常见方法

start和run

• run：是多线程的方法体，调用多线程时执行的代码块，如果直接调用run那么就像直接调用方法一样，不会启动多线程（正确方法时通过调用start方法启动多线程执行run方法）
• start：使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

优先级Priority

线程调度两种调度方式：

• 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
• 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

Java使用的是抢占式调度模型

• 随机性：假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

优先级相关方法

代码演示：

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();
​
        FutureTask<String> ft = new FutureTask<>(mc);
​
        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();
​
        MyCallable mc2 = new MyCallable();
​
        FutureTask<String> ft2 = new FutureTask<>(mc2);
​
        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

守护线程Daemon

相关方法：

代码演示：

public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
​
        t1.setName("女神");
        t2.setName("备胎");
​
        //把第二个线程设置为守护线程
        //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
        t2.setDaemon(true);
​
        t1.start();
        t2.start();
    }
}

sleep

特点：

• 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
•  其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
• 睡眠结束后的线程未必会立刻得到执行
• 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

代码演示：

  public static void main(String[] args) {
        
        
        new Thread(()->{
            try {
                //方式一
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
          
            try {
                //方式二
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

yield

特点：

• 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
• 具体的实现依赖于操作系统的任务调度器
• 有可能会出现让出时间片不成功的现象，因为当让出时间片后就进入就绪状态，很可能会重新再次获得时间片

代码演示：

 public static void main(String[] args) {


       Thread thread = new Thread();
       thread.yield();//进入就绪状态，让出时间片

    }

join

特点：

• 当线程调用join方法之后，就会让主线程进入阻塞状态，直到所有被标记为join方法的线程执行完成后才能开始执行主线程

join的两种调用方式：

• join（）   ：不添加时间参数，即等待线程完成后主线程才开始运行
• join（i）   ：添加时间参数，主线程最多等待i毫秒，超过i毫秒后如果还没完成，主线程也开始执行，如果参数是0，就无限等待，相当于无参调用

代码演示：

  public static void main(String[] args) throws InterruptedException {


        MyThread myThread1 = new MyThread("线程一");

        myThread1.start();

        myThread1.join();
        
        System.out.println("我主线程先完成了");

    }

park，unpark

• 通过LockSupport.park可以暂停某个线程。通过LockSupport.unpark可以恢复某个线程运行
• 与 Object 的 wait & notify 相比 wait，notify 和 notifyAll 必须配合 Object Monitor 一起使用，而 park，unpark 不必
• LockSupport.unpark(t1);park & unpark 是以线程为单位来【阻塞】和【唤醒】线程，而 notify 只能随机唤醒一个等待线程，notifyAll 是唤醒所有等待线程，就不那么【精确】
• park & unpark 可以先 unpark，而 wait & notify 不能先 notify

原理：

每个线程都有自己的一个 Parker 对象，由三部分组成 _counter ， _cond 和 _mutex 打个比喻

线程就像一个旅人， Parker 就像他随身携带的背包，条件变量就好比背包中的帐篷。 _counter 就好比背包中的备用干粮（0 为耗尽， 1 为充足） 调用 park 就是要看需不需要停下来歇息 ，如果备用干粮耗尽，那么钻进帐篷歇息 ，如果备用干粮充足，那么不需停留，继续前进 ，调用 unpark ，就好比令干粮充足 ，如果这时线程还在帐篷，就唤醒让他继续前进，如果这时线程还在运行，那么下次他调用 park 时，仅是消耗掉备用干粮，不需停留继续前进，因为背包空间有限，多次调用 unpark 仅会补充一份备用干粮

1. 当前线程调用 Unsafe.park() 方法

2. 检查 _counter ，本情况为 0 ，这时，获得 _mutex 互斥锁

3. 线程进入 _cond 条件变量阻塞

4. 设置 _counter = 0

1. 调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1

2. 唤醒 _cond 条件变量中的 Thread_0

3. Thread_0 恢复运行

4. 设置 _counter 为 0

 

1. 调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1

2. 当前线程调用 Unsafe.park() 方法

3. 检查 _counter ，本情况为 1 ，这时线程无需阻塞，继续运行

4. 设置 _counter 为 0

interrupt

方法介绍：

interrupt中断sleep，wait，join的线程：

会打断当前的等待状态，如果需要锁的则会等待获取锁，如果不需要所得会进入就绪状态，等待获取时间片

interrupt的作用：是中断线程，实际上并不会直接中断线程，而是给线程一个打断状态，我们需要在代码中判断打断状态是否为true（默认值为false），如果为true表示按照逻辑是希望线程终止的，这时候我们可以写一些善后代码，体面终止线程

•  

  方法	说明
  interrupt()	打断线程
  isinterrupted()	判断是否被打断，不会清空打断标记
  interrupted()	判断是否被打断，会清空打断标记

  会停止线程的阻塞状态，使线程开始运行，并且会清空打断状态，打断状态还是fasle

interrupt打断正常运行的线程：

• 表面上并不会出现任何情况，但是会将打断状态设置成true，用户可以根据实际情况进行处理

interrupt打断park线程：

代码演示：

private static void test4() {
 Thread t1 = new Thread(() -> {
 for (int i = 0; i < 5; i++) {
 log.debug("park...");
 LockSupport.park();
 log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
 }
 });
 t1.start();
 sleep(1);
 t1.interrupt();
}

• park线程只会使打断状态为false的线程进入阻塞，第一次park能够成功，但是当通过interrupt打断了之后，再次park就会失效，除非将打断状态设置成false

wait、notify

原理：

• Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
• BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片
• BLOCKED 线程会在 Owner 线程释放锁时唤醒
• WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入 EntryList 重新竞争
• wait和notify都是object的方法，必须要获取对象的锁之后才能使用wait和notify进行等待和唤醒

 方法介绍

方法	介绍
wait（）	无限期等待，直到被唤醒
wait（long i）	等待i毫秒，如果没被唤醒则停止等待
notify（）	随机唤醒一个
notifyAll（）	唤醒所有wait线程

wait和sleep的区别

sleep时thread方法，而wait时object方法

sleep不需要强制和synchronized配合使用，wait需要和synchronized配合使用

sleep在睡眠的同时不会释放锁，wait在睡眠的时候会释放锁

四、线程安全问题

成员变量和静态变量是否线程安全？

• 如果他们没有共享，则是线程安全的
• 如果他们被共享了，要分为两种情况

1. 如果都是读操作，线程安全
2. 如果有读有写，线程不难全

局部变量是否线程安全？

局部变量是线程安全的：

例如:public static void test1() { int i = 10; i++; }

每个线程在调用test1的时候，会在各个线程的栈帧内创建多分，不同栈帧是互不干扰的

 局部变量引用的对象则不一定安全

• 如果该对象没有逃离方法的作用访问，它是线程安全的
• 如果该对象逃离方法的作用范围，需要考虑线程安全

常见的现场安全类有哪些

• String
• Integer
• Stringbuffer
• Random
• Vector
• Hashtable
• JUC包下的类

线程不安全场景分析（卖票问题）：

案例需求：

• 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

实现步骤：

• 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
• 在SellTicket类中重写run()方法实现卖票，代码步骤如下
• 判断票数大于0，就卖票，并告知是哪个窗口卖的
• 卖了票之后，总票数要减1
• 票卖没了，线程停止
• 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
• 创建SellTicket类的对象
• 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
• 启动线程

代码实现：

public class SellTicket implements Runnable {
    private int tickets = 100;
    //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    @Override
    public void run() {
        while (true) {
            if(ticket <= 0){
                    //卖完了
                    break;
                }else{
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        //创建SellTicket类的对象
        SellTicket st = new SellTicket();
​
        //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");
​
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

出现的问题：

• 相同的票出现了多次
• 出现了负数的票

问题产生原因：

线程执行的随机性导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题

synchronized解决线程不安全问题（必须使用同一把锁）

synchronized有三个中锁定方式：

同步方法的格式：

同步方法：就是把synchronized关键字加到方法上

• 格式：修饰符 synchronized 返回值类型 方法名(方法参数) { 方法体； }
• 同步方法的锁是this

静态同步方法：

同步静态方法：就是把synchronized关键字加到静态方法上

• 格式：修饰符 static synchronized 返回值类型 方法名(方法参数) { 方法体； }
• 同步静态方法的锁对象是字节码文件（类名.class）

同步代码块：

同步代码块：就是把synchronized关键字加到静态方法上

• 格式： synchronized（锁) {方法体}
• 同步代码块的锁对象是任意对象

代码演示：（使用同一把锁）

public class MyRunnable implements Runnable {
    private static int ticketCount = 100;
​
    @Override
    public void run() {
        while(true){
            if("窗口一".equals(Thread.currentThread().getName())){
                //同步方法
                boolean result = synchronizedMthod();
                if(result){
                    break;
                }
            }
​
            if("窗口二".equals(Thread.currentThread().getName())){
                //同步代码块
                synchronized (MyRunnable.class){
                    if(ticketCount == 0){
                       break;
                    }else{
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticketCount--;
                        System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                    }
                }
            }
​
        }
    }


​    //静态同步方法
    private static synchronized boolean synchronizedMthod() {
        if(ticketCount == 0){
            return true;
        }else{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
            return false;
        }
    }
}
public class Demo { public static void main(String[] args) { MyRunnable mr = new MyRunnable();

      Thread t1 = new Thread(mr);
      Thread t2 = new Thread(mr);
​
      t1.setName("窗口一");
      t2.setName("窗口二");
​
      t1.start();
      t2.start();
  }
}

三种synchronized实现方式的区别：

同步方法和同步代码块的区别：

• 同步代码块可与锁定指定代码，同步方法是锁住方法中的所有代码
• 同步代码块可与指定锁，同步方法不能指定锁，有默认的锁

同步方法和同步静态方法的区别

• 同步方法的锁是this，同步静态方法的锁是字节码文件（类名.class）

多线程下的时间日期格式化问题

DateTimeFormatter time = new DateTimeFormatter.ofpartern("yyyy-MM-dd");

Lock锁解决线程不安全问题

方法说明：

代码演示：

  ```java
  public class Ticket implements Runnable {
      //票的数量
      private int ticket = 100;
      private Object obj = new Object();
      private ReentrantLock lock = new ReentrantLock();
​
      @Override
      public void run() {
          while (true) {
              //synchronized (obj){//多个线程必须使用同一把锁.
              try {
                  lock.lock();
                  if (ticket <= 0) {
                      //卖完了
                      break;
                  } else {
                      Thread.sleep(100);
                      ticket--;
                      System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                  }
              } catch (InterruptedException e) {
                  e.printStackTrace();
              } finally {
                  lock.unlock();
              }
              // }
          }
      }
  }
​
  public class Demo {
      public static void main(String[] args) {
          Ticket ticket = new Ticket();
​
          Thread t1 = new Thread(ticket);
          Thread t2 = new Thread(ticket);
          Thread t3 = new Thread(ticket);
​
          t1.setName("窗口一");
          t2.setName("窗口二");
          t3.setName("窗口三");
​
          t1.start();
          t2.start();
          t3.start();
      }
  }

死锁现象

概述

• 线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行

什么情况下会产生死锁

• 互斥条件：线程(进程)对于所分配到的资源具有排它性，即一个资源只能被一个线程(进程)占用，直到被该线程(进程)释放
• 请求与保持条件：一个线程(进程)因请求被占用资源而发生阻塞时，对已获得的资源保持不放。
• 不剥夺条件：线程(进程)已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
• 循环等待条件：当发生死锁时，所等待的线程(进程)必定会形成一个环路（类似于死循环），造成永阻塞

代码演示：

public class Demo {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();
​
        new Thread(()->{
            while(true){
                synchronized (objA){
                    //线程一
                    synchronized (objB){
                        System.out.println("小康同学正在走路");
                    }
                }
            }
        }).start();
​
        new Thread(()->{
            while(true){
                synchronized (objB){
                    //线程二
                    synchronized (objA){
                        System.out.println("小薇同学正在走路");
                    }
                }
            }
        }).start();
    }
}

活锁现象

活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束，可以通过增加随机数睡眠时间避开互相影响

代码演示

public class TestLiveLock {
 static volatile int count = 10;
 static final Object lock = new Object();
 public static void main(String[] args) {
 new Thread(() -> {
 // 期望减到 0 退出循环
 while (count > 0) {
 sleep(0.2);
 count--;
 log.debug("count: {}", count);
 }
 }, "t1").start();
 new Thread(() -> {
 // 期望超过 20 退出循环
 while (count < 20) {
 sleep(0.2);
 count++;
 log.debug("count: {}", count);
 }
 }, "t2").start();
 }
}

饥饿锁

很多教程中把饥饿定义为，一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束

不可见问题（线程之间不能读取最新的共享数据）

问题分析：

当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题

1. 堆内存是唯一的，每一个线程都有自己的线程栈。
2. 每一个线程在使用堆里面变量的时候，都会先拷贝一份到线程栈的变量副本中。
3. 在线程中，每一次使用优先从变量的副本中获取的。
4. 有可能A在修改了之后，将堆里的变量值更替，但是B仍然读取变量副本中的值，造成数据不统一，然而无法控制B重新读取堆内存中 新的值得时间

用volatile关键字解决不可见问题

Volatile关键字特点 :

• 可见性： 强制线程每次在使用的时候，都会看一下共享区域最新的值
• volatile不保证原子性
• 禁止重排序(有序性）：加上volatile的字段前面的代码都禁止重排序

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码

static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...; 
j = ...;

可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是

i = ...; 
j = ...;

也可以是

j = ...;
i = ...;

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性。为什么要有重排指令这项优化呢？

 图中左侧是 3 行 Java 代码，右侧是这 3 行代码可能被转化成的指令。可以看出 a = 100 对应的是 Load a、Set to 100、Store a，意味着从主存中读取 a 的值，然后把值设置为 100，并存储回去，同理， b = 5 对应的是下面三行  Load b、Set to 5、Store b，最后的 a = a + 10，对应的是 Load a、Set to 110、Store a。如果你仔细观察，会发现这里有两次“Load a”和两次“Store a”，说明存在一定的重排序的优化空间。

重排序后， a 的两次操作被放到一起，指令执行情况变为 Load a、Set to 100、Set to 110、 Store a。下面和 b 相关的指令不变，仍对应 Load b、 Set to 5、Store b。

可以看出，重排序后 a 的相关指令发生了变化，节省了一次 Load a 和一次 Store a。重排序通过减少执行指令，从而提高整体的运行速度，这就是重排序带来的优化和好处。

重排序的 3 种情况

下面我们来看一下重排序的 3 种情况。

（1）编译器优化

编译器（包括 JVM、JIT 编译器等）出于优化的目的，例如当前有了数据 a，把对 a 的操作放到一起效率会更高，避免读取 b 后又返回来重新读取 a 的时间开销，此时在编译的过程中会进行一定程度的重排。不过重排序并不意味着可以任意排序，它需要需要保证重排序后，不改变单线程内的语义，否则如果能任意排序的话，程序早就逻辑混乱了。

（2）CPU 重排序

CPU 同样会有优化行为，这里的优化和编译器优化类似，都是通过乱序执行的技术来提高整体的执行效率。所以即使之前编译器不发生重排，CPU 也可能进行重排，我们在开发中，一定要考虑到重排序带来的后果。

（3） 内存的“重排序”

内存系统内不存在真正的重排序，但是内存会带来看上去和重排序一样的效果，所以这里的“重排序”打了双引号。由于内存有缓存的存在，在 JMM 里表现为主存和本地内存，而主存和本地内存的内容可能不一致，所以这也会导致程序表现出乱序的行为。

举个例子，线程 1 修改了 a 的值，但是修改后没有来得及把新结果写回主存或者线程 2 没来得及读到最新的值，所以线程 2 看不到刚才线程 1 对 a 的修改，此时线程 2 看到的 a 还是等于初始值。但是线程 2 却可能看到线程 1 修改 a 之后的代码执行效果，表面上看起来像是发生了重顺序。

synchronized解决不可见问题

在操作共享数据的位置加上synchronized锁就会读取最新的数据

原子性问题

例如i++等操作执行过程是这样的，首先要先拿到内存中的数据，然后再保存到变量副本中，这时候在修改变量副本的值，然后再把变量副本的值替换掉内存中的值，在这个运算过程中走了三个步骤，在多线程环境中，可能修改好变量副本了，准备要往内存中复制这个过程中，就被其他线程修改了值，这时候再去复制，就导致结果最终不一致

解决方法：

使用synchronized同步代码块锁住运算过程

使用atomic包下的对象（atomicInteger）进行修改，在下面有介绍）

LongAdder

LongAdder 是并发大师 @author Doug Lea （大哥李）的作品，设计的非常精巧

LongAdder 类有几个关键域

// 累加单元数组 , 懒惰初始化

transient volatile Cell [] cells ;

// 基础值 , 如果没有竞争 , 则用 cas 累加这个域

transient volatile long base ;

// 在 cells 创建或扩容时 , 置为 1, 表示加锁

transient volatile int cellsBusy ;

伪共享原理

// 防止缓存行伪共享
@sun.misc.Contended
static final class Cell {
 volatile long value;
 Cell(long x) { value = x; }
 
 // 最重要的方法, 用来 cas 方式进行累加, prev 表示旧值, next 表示新值
 final boolean cas(long prev, long next) {
 return UNSAFE.compareAndSwapLong(this, valueOffset, prev, next);
 }
 // 省略不重要代码
}

cell为累加单元，而方法上的@sun.misc.Contended 的作用在下面介绍

需要重缓存说起，在操作系统种由以下几中数据读取放方式，从cpu内部寄存器、一级缓存、二级缓存、三级缓存、内存

现在比较以下内存与缓存的数据差别

因为 CPU 与 内存的速度差异很大，需要靠预读数据至缓存来提升效率。

而缓存以缓存行为单位，每个缓存行对应着一块内存，一般是 64 byte （ 8 个 long ）

缓存的加入会造成数据副本的产生，即同一份数据会缓存在不同核心的缓存行中

CPU 要保证数据的一致性，如果某个 CPU 核心更改了数据，其它 CPU 核心对应的整个缓存行必须失效

因为 Cell 是数组形式，在内存中是连续存储的，一个 Cell 为 24 字节（ 16 字节的对象头和 8 字节的 value ），因

此缓存行可以存下 2 个的 Cell 对象。这样问题来了：

Core-0 要修改 Cell[0]

Core-1 要修改 Cell[1]

无论谁修改成功，都会导致对方 Core 的缓存行失效，比如 Core-0 中 Cell[0]=6000, Cell[1]=8000 要累加

Cell[0]=6001, Cell[1]=8000 ，这时会让 Core-1 的缓存行失效

@sun.misc.Contended 用来解决这个问题，它的原理是在使用此注解的对象或字段的前后各增加 128 字节大小的

padding ，从而让 CPU 将对象预读至缓存时占用不同的缓存行，这样，不会造成对方缓存行的失效

五、模式应用

概述

• 生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。
• 所谓生产者消费者问题，实际上主要是包含了两类线程：
• 一类是生产者线程用于生产数据
• 一类是消费者线程用于消费数据
• 为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
• 生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
• 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

应用一：等待（wait）唤醒（notify）方法

方法介绍：

案例需求

• 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量
• 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

1. 判断是否有包子,决定当前线程是否执行
2. 如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子
3. 生产包子之后,更新桌子上包子状态,唤醒消费者消费包子

• 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

1. 判断是否有包子,决定当前线程是否执行
2. 如果没有包子,就进入等待状态,如果有包子,就消费包子
3. 消费包子后,更新桌子上包子状态,唤醒生产者生产包子

• 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

1. 创建生产者线程和消费者线程对象
2. 分别开启两个线程

代码实现：（要使用同一把锁来调用wait和notify）

public class Desk {

    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    //public static boolean flag = false;
    private boolean flag;

    //汉堡包的总数量
    //public static int count = 10;
    //以后我们在使用这种必须有默认值的变量
   // private int count = 10;
    private int count;

    //锁对象
    //public static final Object lock = new Object();
    private final Object lock = new Object();

    public Desk() {
        this(false,10); // 在空参内部调用带参,对成员变量进行赋值,之后就可以直接使用成员变量了
    }

    public Desk(boolean flag, int count) {
        this.flag = flag;
        this.count = count;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Object getLock() {
        return lock;
    }

    @Override
    public String toString() {
        return "Desk{" +
                "flag=" + flag +
                ", count=" + count +
                ", lock=" + lock +
                '}';
    }
}

public class Cooker extends Thread {

    private Desk desk;

    public Cooker(Desk desk) {
        this.desk = desk;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。

    @Override
    public void run() {
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(!desk.isFlag()){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        desk.setFlag(true);
                        desk.getLock().notifyAll();
                    }else{
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Foodie extends Thread {
    private Desk desk;

    public Foodie(Desk desk) {
        this.desk = desk;
    }

    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(desk.isFlag()){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        desk.setFlag(false);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount() - 1);
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

    }
}

public class Demo {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
                叫醒等待的生产者继续生产
        汉堡包的总数量减一*/

        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/

        Desk desk = new Desk();

        Foodie f = new Foodie(desk);
        Cooker c = new Cooker(desk);

        f.start();
        c.start();

    }
}

应用搜索二：阻塞队列BlockingQueue

常见BlockingQueue:

• ArrayBlockingQueue: 底层是数组,有界
• LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值

BlockingQueue的核心方法介绍：

案例需求

• 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

1. 构造方法中接收一个阻塞队列对象
2. 在run方法中循环向阻塞队列中添加包子
3. 打印添加结果

• 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

1. 构造方法中接收一个阻塞队列对象
2. 在run方法中循环获取阻塞队列中的包子
3. 打印获取结果

• 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

1. 创建阻塞队列对象
2. 创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象
3. 分别开启两个线程

代码实现：

public class Cooker extends Thread {
​
    private ArrayBlockingQueue<String> bd;
​
    public Cooker(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
​
    @Override
    public void run() {
        while (true) {
            try {
                bd.put("汉堡包");
                System.out.println("厨师放入一个汉堡包");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
​
public class Foodie extends Thread {
    private ArrayBlockingQueue<String> bd;
​
    public Foodie(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
​
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一
​
        //套路:
        //1. while(true)死循环
        //2. synchronized 锁,锁对象要唯一
        //3. 判断,共享数据是否结束. 结束
        //4. 判断,共享数据是否结束. 没有结束
        while (true) {
            try {
                String take = bd.take();
                System.out.println("吃货将" + take + "拿出来吃了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
​
    }
}
​
public class Demo {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);
​
        Foodie f = new Foodie(bd);
        Cooker c = new Cooker(bd);
​
        f.start();
        c.start();
    }
}

六、线程池相关

线程池存在的意义：

系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系

统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就

会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。

线程池的设计思路 :

1. 准备一个任务容器
2. 一次性启动多个(2个)消费者线程
3. 刚开始任务容器是空的，所以线程都在wait
4. 直到一个外部线程向这个任务容器中扔了一个"任务"，就会有一个消费者线程被唤醒
5. 这个消费者线程取出"任务"，并且执行这个任务，执行完毕后，继续等待下一次任务的到来

Executors默认线程池

Executors.newCachedThreadPool()创建默认线程池：(全部都是救急线程）

​
​
//static ExecutorService newCachedThreadPool()   创建一个默认的线程池
//static newFixedThreadPool(int nThreads)       创建一个指定最多线程数量的线程池
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
​
public class MyThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {
​
        //1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Executors --- 可以帮助我们创建线程池对象
        //ExecutorService --- 可以帮助我们控制线程池
​
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });
​
        //Thread.sleep(2000);
​
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });
​
        executorService.shutdown();
    }
}
​

Executors.newFixedThreadPool(int i );创建最大线程数为i的线程池（全部都是核心线程)

package com.itheima.mythreadpool;
​
//static ExecutorService newFixedThreadPool(int nThreads)
//创建一个指定最多线程数量的线程池
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
​
public class MyThreadPoolDemo2 {
    public static void main(String[] args) {
        //参数不是初始值而是最大值
        ExecutorService executorService = Executors.newFixedThreadPool(10);
​
        ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
        System.out.println(pool.getPoolSize());//0
​
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });
​
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });
​
        System.out.println(pool.getPoolSize());//2
//        executorService.shutdown();
    }
}
​

ThreadPoolExecutor线程池

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);

参数讲解：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
    
corePoolSize：   核心线程的最大值，不能小于0
maximumPoolSize：最大线程数，不能小于等于0，maximumPoolSize >= corePoolSize
keepAliveTime：  空闲线程最大存活时间,不能小于0
unit：           时间单位
workQueue：      任务队列，不能为null
threadFactory：  创建线程工厂,不能为null      
handler：        任务的拒绝策略,不能为null  

代码实现 :

package com.itheima.mythreadpool;
​
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
​
public class MyThreadPoolDemo3 {
//    参数一：核心线程数量
//    参数二：最大线程数
//    参数三：空闲线程最大存活时间
//    参数四：时间单位
//    参数五：任务队列
//    参数六：创建线程工厂
//    参数七：任务的拒绝策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
​
        pool.shutdown();
    }
}

线程执行任务说明：

线程池中的线程是惰性创建的，仅在需要的时候才开始创建，线程池中的线程有核心线程和救急线程，核心线程加上救急线程总数不能超过最大线程数，在这里假设创建了核心线程数为2，最大线程数为3，阻塞队列为2的线程池，当有两个任务需要被线程执行的时候，这时候核心线程会先执行任务，当第三第四个任务来的时候，这时候就会进入阻塞队列中等待，如果这时候再来一条任务，就会临时创建一个救急线程，后面如果再来就会根据拒绝策略处理，当救急线程完成任务的时候，会等待一段时间，这个时间就是我们设置的过期时间，由数量和单位组成。而核心线程完成任务后仍然保留。

线程池中的方法：

1、submit（提交单个任务，能获取返回值）

     ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,4,10, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
      Future futureTask=  threadPoolExecutor.submit(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                TimeUnit.SECONDS.sleep(1);
                return "OK";
            }
        });
        Object o = futureTask.get();
        TimeUnit.SECONDS.sleep(2);
        System.out.println(o);

2、

// 执行任务

void execute ( Runnable command );

// 提交任务 task ，用返回值 Future 获得任务执行结果

< T > Future < T > submit ( Callable < T > task );

// 提交 tasks 中所有任务

< T > List < Future < T >> invokeAll ( Collection <? extends Callable < T >> tasks ) throws InterruptedException ;

// 提交 tasks 中所有任务，带超时时间

< T > List < Future < T >> invokeAll ( Collection <? extends Callable < T >> tasks , long timeout , TimeUnit unit ) throws InterruptedException ;

// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消

< T > T invokeAny ( Collection <? extends Callable < T >> tasks ) throws InterruptedException , ExecutionException ;

// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消，带超时时间

< T > T invokeAny ( Collection <? extends Callable < T >> tasks , long timeout , TimeUnit unit )

throws InterruptedException , ExecutionException , TimeoutException ;

任务拒接策略：

RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。

注：明确线程池对多可执行的任务数 = 队列容量 + 最大线程数

• ThreadPoolExecutor.AbortPolicy:             丢弃任务并抛出RejectedExecutionException异常。是默认的策略。
• ThreadPoolExecutor.DiscardPolicy：          丢弃任务，但是不抛出异常 这是不推荐的做法。
• ThreadPoolExecutor.DiscardOldestPolicy：    抛弃队列中等待最久的任务 然后把当前任务加入队列中。
• ThreadPoolExecutor.CallerRunsPolicy:        调用任务的run()方法绕过线程池直接执行。

AbortPolicy代码演示：

public class ThreadPoolExecutorDemo01 {
​
    public static void main(String[] args) {
​
        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ;
​
        // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用AbortPolicy这个任务处理策略的时候，就会抛出异常
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
            });
        }
    }
}

控制台输出结果

pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-3---->> 执行了任务

控制台报错，仅仅执行了4个任务，有一个任务被丢弃了

DiscardPolicy代码演示：

public class ThreadPoolExecutorDemo02 {
    public static void main(String[] args) {
        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardPolicy()) ;
​
        // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用DiscardPolicy这个任务处理策略的时候，控制台不会报错
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
            });
        }
    }
}

控制台输出结果

pool-1-thread-1---->> 执行了任务
pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务

控制台没有报错，仅仅执行了4个任务，有一个任务被丢弃了

DiscardOldestPolicy代码演示：

public class ThreadPoolExecutorDemo02 {
    public static void main(String[] args) {
        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor;
        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardOldestPolicy());
        // 提交5个任务
        for(int x = 0 ; x < 5 ; x++) {
            // 定义一个变量，来指定指定当前执行的任务;这个变量需要被final修饰
            final int y = x ;
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务" + y);
            });     
        }
    }
}

控制台输出结果

pool-1-thread-2---->> 执行了任务2
pool-1-thread-1---->> 执行了任务0
pool-1-thread-3---->> 执行了任务3
pool-1-thread-1---->> 执行了任务4

由于任务1在线程池中等待时间最长，因此任务1被丢弃。

CallerRunsPolicy代码演示

public class ThreadPoolExecutorDemo04 {
    public static void main(String[] args) {
​
        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor;
        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.CallerRunsPolicy());
​
        // 提交5个任务
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
            });
        }
    }
}

控制台输出结果

pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-1---->> 执行了任务
main---->> 执行了任务

通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。

任务调度

方式一:Timer

缺点：

通过Timer实现任务调度，所有的任务都是通过一个线程完成的，也就是任务串行化执行，效率非常低下，如果其中有一个任务执行的很久，后面的任务也要跟着等待，如果某个任务执行失败了，抛出异常，那么后面的任务就无法执行了

public static void main(String[] args) {
    Timer timer = new Timer();
    TimerTask task1 = new TimerTask() {
        @Override
        public void run() {
            log.debug("task 1");
            sleep(2);
        }
    };
    TimerTask task2 = new TimerTask() {
        @Override
        public void run() {
            log.debug("task 2");
        }
    };
    // 使用 timer 添加两个任务，希望它们都在 1s 后执行
    // 但由于 timer 内只有一个线程来顺序执行队列中的任务，因此『任务1』的延时，影响了『任务2』的执行
 timer.schedule(task1, 1000);
 timer.schedule(task2, 1000);
}

方式二：scheduledExecutorService.scheduleAtFixedRate

在创建线程池的时候指定核心线程池的个数，之后就会在多线程的情景下调度多个任务，不同的任务之间互不干扰（其中某个线程时间过久或者出了异常不影响其他线程的进行），scheduleAtFixedRate方法会延时并且以一定的时间间隔重复执行任务，但是如果设置了延时时间小于任务本身运行的时间，那么重复当前任务的时候就会紧挨着运行，例如下面的任务执行时常为4，但是设置的延时间隔时间为3秒，当执行完第一次耗时为4秒之后，又会紧挨着重复执行

 public static void main(String[] args) throws InterruptedException, ExecutionException {

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        

        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                  try {
                    TimeUnit.SECONDS.sleep(4);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },3,3,TimeUnit.SECONDS);

    }

方式二：scheduledExecutorService.scheduleWithFixedDelay

与上面不同的是，这次添加的重复时间是任务间隔时间，也就是说程序执行完成需要4秒，但是还需要等待3秒的间隔时间，才会开始下一次的重复

public static void main(String[] args) throws InterruptedException, ExecutionException {

    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);


    scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
        @Override
        public void run() {
          try {
                    TimeUnit.SECONDS.sleep(4);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
    },3,3,TimeUnit.SECONDS);

}

如何处理线程池中的线程执行任务过程中的异常？

1、通过try catch 

2、通过future

七、线程安全类

Atomic包

概述：java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。本次我们只讲解

使用原子的方式更新基本类型，使用原子的方式更新基本类型Atomic包提供了以下3个类：

• AtomicBoolean： 原子更新布尔类型
• AtomicInteger： 原子更新整型
• AtomicLong： 原子更新长整型

以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下：

• public AtomicInteger()：                 初始化一个默认值为0的原子型Integer
• public AtomicInteger(int initialValue)：  初始化一个指定值的原子型Integer
• int get():                              获取值
• int getAndIncrement():                   以原子方式将当前值加1，注意，这里返回的是自增前的值。
• int incrementAndGet():                   以原子方式将当前值加1，注意，这里返回的是自增后的值。
• int addAndGet(int data):                 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
• int getAndSet(int value):                以原子方式设置为newValue的值，并返回旧值。

代码实现：

package com.itheima.threadatom3;
​
import java.util.concurrent.atomic.AtomicInteger;
​
public class MyAtomIntergerDemo1 {
//    public AtomicInteger()：                  初始化一个默认值为0的原子型Integer
//    public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
    public static void main(String[] args) {
        AtomicInteger ac = new AtomicInteger();
        System.out.println(ac);
​
        AtomicInteger ac2 = new AtomicInteger(10);
        System.out.println(ac2);
    }
​
}
package com.itheima.threadatom3;
​
import java.lang.reflect.Field;
import java.util.concurrent.atomic.AtomicInteger;
​
public class MyAtomIntergerDemo2 {
//    int get():                获取值
//    int getAndIncrement():     以原子方式将当前值加1，注意，这里返回的是自增前的值。
//    int incrementAndGet():     以原子方式将当前值加1，注意，这里返回的是自增后的值。
//    int addAndGet(int data):   以原子方式将参数与对象中的值相加，并返回结果。
//    int getAndSet(int value):  以原子方式设置为newValue的值，并返回旧值。
    public static void main(String[] args) {
//        AtomicInteger ac1 = new AtomicInteger(10);
//        System.out.println(ac1.get());
​
//        AtomicInteger ac2 = new AtomicInteger(10);
//        int andIncrement = ac2.getAndIncrement();
//        System.out.println(andIncrement);
//        System.out.println(ac2.get());
​
//        AtomicInteger ac3 = new AtomicInteger(10);
//        int i = ac3.incrementAndGet();
//        System.out.println(i);//自增后的值
//        System.out.println(ac3.get());
​
//        AtomicInteger ac4 = new AtomicInteger(10);
//        int i = ac4.addAndGet(20);
//        System.out.println(i);
//        System.out.println(ac4.get());
​
        AtomicInteger ac5 = new AtomicInteger(100);
        int andSet = ac5.getAndSet(20);
        System.out.println(andSet);
        System.out.println(ac5.get());
    }
}

AtomicInteger原理 : 自旋锁 + CAS 算法

CAS（乐观锁）算法：

有3个操作数（内存值V， 旧的预期值A，要修改的值B）

当旧的预期值A == 内存值 此时修改成功，将V改为B

当旧的预期值A！=内存值 此时修改失败，不做任何操作并重新获取现在的最新值，再重复之前的方法（这个重新获取的动作就是自旋）

AtomicReference代码演示

   AtomicReference<BigDecimal> bigDecimalAtomicReference = new AtomicReference<>(new BigDecimal("10000"));

                        for (int i =0;i<1000;i++){

                          Thread x =    new Thread(()->{

                    //可视化乐观锁
//              while (true){
//                  BigDecimal bigDecimal = bigDecimalAtomicReference.getReference();
//                  BigDecimal subtract = bigDecimal.subtract(BigDecimal.TEN);
//
//                  if (bigDecimalAtomicReference.compareAndSet(bigDecimal,subtract,false,true) ){
//                      System.out.println(bigDecimalAtomicReference.getReference());
//                      break;
//                  }
//              }

           bigDecimalAtomicReference.getAndSet(bigDecimalAtomicReference.get().subtract(BigDecimal.TEN));
                            });

                          x.start();
                            x.join();


                        }


        TimeUnit.SECONDS.sleep(20);
        System.out.println(bigDecimalAtomicReference.get());



    }

主线程仅能判断出共享变量的值与最初值 A 是否相同，不能感知到这种从 A 改为 B 又 改回 A 的情况，如果主线程

希望：

只要有其它线程【动过了】共享变量，那么自己的 cas 就算失败，这时，仅比较值是不够的，需要再加一个版本号

这时候就出现了AtomicStampedReference

AtomicStampedReference代码演示

 public static void main(String[] args) throws InterruptedException {
        AtomicStampedReference<BigDecimal> bigDecimalAtomicReference = new AtomicStampedReference<>(new BigDecimal("10000"), 0);

        for (int i = 0; i < 1000; i++) {

            Thread x = new Thread(() -> {


                while (true) {
                    BigDecimal bigDecimal = bigDecimalAtomicReference.getReference();
                    BigDecimal subtract = bigDecimal.subtract(BigDecimal.TEN);
                    int stamp = bigDecimalAtomicReference.getStamp();
                    if (bigDecimalAtomicReference.compareAndSet(bigDecimal, subtract, stamp, stamp + 1)) {
                        System.out.println(bigDecimalAtomicReference.getReference());
                        break;
                    }
                }

            });
            x.start();
            x.join();
        }
    }

 AtomicStampedReference 可以给原子引用加上版本号，追踪原子引用整个的变化过程，如：

A - > B - > A - > C ，通过 AtomicStampedReference ，我们可以知道，引用变量中途被更改了几次。

但是有时候，并不关心引用变量更改了几次，只是单纯的关心 是否更改过 ，所以就有了

AtomicMarkableReference

AtomicMarkableReference代码演示

  AtomicMarkableReference<BigDecimal> bigDecimalAtomicReference = new AtomicMarkableReference<>(new BigDecimal("10000"), true);

        for (int i = 0; i < 1000; i++) {

            Thread x = new Thread(() -> {


                while (true) {
                    BigDecimal bigDecimal = bigDecimalAtomicReference.getReference();
                    BigDecimal subtract = bigDecimal.subtract(BigDecimal.TEN);
                    if (bigDecimalAtomicReference.compareAndSet(bigDecimal, subtract, true, false)) {
                        System.out.println(bigDecimalAtomicReference.getReference());
                        break;
                    }
                }

            });
            x.start();
            x.join();
        }
    }

Hashtable

Hashtable出现的原因 : 在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable。

缺点：hashtable是采用synchronized锁住整张表，只有一个线程能访问表，效率非常低下

代码演示：

package com.itheima.mymap;
​
import java.util.HashMap;
import java.util.Hashtable;
​
public class MyHashtableDemo {
    public static void main(String[] args) throws InterruptedException {
        Hashtable<String, String> hm = new Hashtable<>();
​
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });
​
​
        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });
​
        t1.start();
        t2.start();
​
        System.out.println("----------------------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);
​
        //0-0 1-1 ..... 50- 50
​
        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50
​
​
    }
}

ConcurrentHashMap

ConcurrentHashMap出现的原因：

在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下，基于以上两个原因我们可以使用JDK1.5以后所提供的ConcurrentHashMap。

代码实现：

package com.itheima.mymap;
​
import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;
​
public class MyConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>(100);
​
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });
​
​
        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });
​
        t1.start();
        t2.start();
​
        System.out.println("----------------------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);
​
        //0-0 1-1 ..... 50- 50
​
        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50
    }
}

JDK7实现原理

总结：

初始化：当新建一个concurrentHashMap的时候，会默认创建一个长度为16的Segment数组，是不可扩容的，segment数组的0号索引存放的是一个指向HashEntry数组的地址，segment的其他索引均为null，而0号索引指向的HashEntry是一个长度为2的数组，扩容因子为0.75，这个数组作为模板数字，以后出现新的HashEntry都以这个数组为模板。

插入数据情况一：假设要插入的hash值通过计算，要存放的位置在Segment的4号索引。此时4号索引为null，那么会创造一个跟模板HashEntry一样的HashEntry，长度为2 ，把地址存放在Segment的4号索引，这时候通过hash值得二次哈希得到需要存放在HashEntry上的位置，假设是0，此时HashEntry得0号索引为空，那么就直接插入。

插入数据情况二：假设要插入的hash值通过计算，还是要放在segment的4号索引，此时4号索引b不为null，则通过二次哈希查找要放在HashEntry上的位置，假设还是0，此时0上面已经存放了值，这时候通过equlas进行属性值比较，如果属性值相同，则放弃插入，如果属性值不同，则放入0号索引位置，然后把老元素挂载新元素下面

插入数据情况三：前面的情况都一样，还是放在segment的4号索引上，然后通过二次哈希找到HashEntry上的索引为1，即便此时1号索引为空，也不会直接插入数据，由于扩容因子为0.75，而hashEntry长度为2，2*0.75=1.5，如果还要再1号索引上插入数据，长度就为2，大于0.75，索引需要先扩容，长度变成4之后，再将数据插入1号索引上

JDK8实现原理

总结 :

1. 如果使用空参构造创建ConcurrentHashMap对象，则什么事情都不做。 在第一次添加元素的时候创建哈希表
2. 计算当前元素应存入的索引。
3. 如果该索引位置为null，则利用cas算法，将本结点添加到数组中。
4. 如果该索引位置不为null，则利用volatile关键字获得当前位置最新的结点地址，挂在他下面，变成链表。
5. 当链表的长度大于等于8时，自动转换成红黑树6，以链表或者红黑树头结点为锁对象，配合悲观锁保证多线程操作集合时数据的安全性

 BlockingQueue

常见BlockingQueue:

• ArrayBlockingQueue: 底层是数组,有界
• LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值

BlockingQueue的核心方法介绍：

案例需求

• 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

1. 构造方法中接收一个阻塞队列对象
2. 在run方法中循环向阻塞队列中添加包子
3. 打印添加结果

• 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

1. 构造方法中接收一个阻塞队列对象
2. 在run方法中循环获取阻塞队列中的包子
3. 打印获取结果

• 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

1. 创建阻塞队列对象
2. 创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象
3. 分别开启两个线程

代码实现：

public class Cooker extends Thread {
​
    private ArrayBlockingQueue<String> bd;
​
    public Cooker(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
​
    @Override
    public void run() {
        while (true) {
            try {
                bd.put("汉堡包");
                System.out.println("厨师放入一个汉堡包");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
​
public class Foodie extends Thread {
    private ArrayBlockingQueue<String> bd;
​
    public Foodie(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
​
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一
​
        //套路:
        //1. while(true)死循环
        //2. synchronized 锁,锁对象要唯一
        //3. 判断,共享数据是否结束. 结束
        //4. 判断,共享数据是否结束. 没有结束
        while (true) {
            try {
                String take = bd.take();
                System.out.println("吃货将" + take + "拿出来吃了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
​
    }
}
​
public class Demo {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);
​
        Foodie f = new Foodie(bd);
        Cooker c = new Cooker(bd);
​
        f.start();
        c.start();
    }
}

 CountDownLatch

方法介绍：

方法	解释
public CountDownLatch(int count)	参数传递线程数，表示等待线程数量
public void await()	让线程等待
public void countDown()	当前线程执行完毕

使用场景： 让某一条线程等待其他线程执行完毕之后再执行

代码实现 :

package com.itheima.mycountdownlatch;
​
import java.util.concurrent.CountDownLatch;
​
public class ChileThread1 extends Thread {
​
    private CountDownLatch countDownLatch;
    public ChileThread1(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
​
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 10; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}
​
package com.itheima.mycountdownlatch;
​
import java.util.concurrent.CountDownLatch;
​
public class ChileThread2 extends Thread {
​
    private CountDownLatch countDownLatch;
    public ChileThread2(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 15; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}
​
package com.itheima.mycountdownlatch;
​
import java.util.concurrent.CountDownLatch;
​
public class ChileThread3 extends Thread {
​
    private CountDownLatch countDownLatch;
    public ChileThread3(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 20; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}
​
package com.itheima.mycountdownlatch;
​
import java.util.concurrent.CountDownLatch;
​
public class MotherThread extends Thread {
    private CountDownLatch countDownLatch;
    public MotherThread(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
​
    @Override
    public void run() {
        //1.等待
        try {
            //当计数器变成0的时候，会自动唤醒这里等待的线程。
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //2.收拾碗筷
        System.out.println("妈妈在收拾碗筷");
    }
}
​
package com.itheima.mycountdownlatch;
​
import java.util.concurrent.CountDownLatch;
​
public class MyCountDownLatchDemo {
    public static void main(String[] args) {
        //1.创建CountDownLatch的对象，需要传递给四个线程。
        //在底层就定义了一个计数器，此时计数器的值就是3
        CountDownLatch countDownLatch = new CountDownLatch(3);
        //2.创建四个线程对象并开启他们。
        MotherThread motherThread = new MotherThread(countDownLatch);
        motherThread.start();
​
        ChileThread1 t1 = new ChileThread1(countDownLatch);
        t1.setName("小明");
​
        ChileThread2 t2 = new ChileThread2(countDownLatch);
        t2.setName("小红");
​
        ChileThread3 t3 = new ChileThread3(countDownLatch);
        t3.setName("小刚");
​
        t1.start();
        t2.start();
        t3.start();
    }
}

总结 :

1.  CountDownLatch(int count)：参数写等待线程的数量。并定义了一个计数器。
2. await()：让线程等待，当计数器为0时，会唤醒等待的线程
3.  countDown()： 线程执行完毕时调用，会将计数器-1。

CyclicBarrier

循环栅栏，用来进行线程协作，等待线程满足某个计数。构造时设置『计数个数』，每个线程执

行到某个需要 “ 同步 ” 的时刻调用 await() 方法进行等待，当等待的线程数满足『计数个数』时，继续执行，当设定的数减到0时又会恢复之前设定的值，可重复循环

注意：要执行的任务数量必须与线程池中的最大容量相同

代码演示

    CyclicBarrier cb = new CyclicBarrier(2,()->{
            System.out.println("执行完一轮");
        }); // 个数为2时才会继续执行
        new Thread(()->{
            System.out.println("线程1开始.."+new Date());
            try {
                cb.await(); // 当个数不足时，等待
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("线程1继续向下运行..."+new Date());
        }).start();
        new Thread(()->{
            System.out.println("线程2开始.."+new Date());
            try { Thread.sleep(2000); } catch (InterruptedException e) { }
            try {
                cb.await(); // 2 秒后，线程个数够2，继续运行
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("线程2继续向下运行..."+new Date());
        }).start();
    }

 Semaphore

使用场景 :

可以控制访问特定资源的线程数量。

实现步骤 :

1. 需要有人管理这个通道
2. 当有车进来了，发通行许可证
3. 当车出去了，收回通行许可证
4. 如果通行许可证发完了，那么其他车辆只能等着

代码实现 :

package com.itheima.mysemaphore;
​
import java.util.concurrent.Semaphore;
​
public class MyRunnable implements Runnable {
    //1.获得管理员对象，
    private Semaphore semaphore = new Semaphore(2);
    @Override
    public void run() {
        //2.获得通行证
        try {
            semaphore.acquire();
            //3.开始行驶
            System.out.println("获得了通行证开始行驶");
            Thread.sleep(2000);
            System.out.println("归还通行证");
            //4.归还通行证
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
​
package com.itheima.mysemaphore;
​
public class MySemaphoreDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
​
        for (int i = 0; i < 100; i++) {
            new Thread(mr).start();
        }
    }
}

八、几种锁的介绍

Synchronized

前置知识：Monitor

java对象在内存中由三部分组成：对齐填充字节、实例数据、对象头（重点知识）

• 对齐填充字节：因为JVM要求java的对象占的内存大小应该是8字节的倍数，所以后面有几个字节用于把对象的大小补齐至8字节的倍数，没有特别的功能
• 数据实力：对象的实例数据就是在java代码中能看到的属性和他们的值。
• 对象头：

对象头由三个部分组成：1、Mark Word；2、指向类的指针；3、数组长度（只有数组对象才有）

32位虚拟机 ：

创建的普通对象为：

|-----------------------------------------------------------|
|                    Object Header (64 bits)                |
|---------------------------------|-------------------------|
|             Mark Word (32 bits) | Klass Word (32 bits)    |
|---------------------------------|-------------------------|

 数组对象：

|---------------------------------------------------------------------------------|
|                                  Object Header (96 bits)                        |
|--------------------------------|-----------------------|------------------------|
|       Mark Word(32bits)        | Klass Word(32bits)    | array length(32bits)   |
|--------------------------------|-----------------------|------------------------|

 32位虚拟机对象头详情如下

|-----------------------------------------------------------------------------------------------------------------|
|                                             Object Header(64bits)                                               |
|-----------------------------------------------------------------------------------------------------------------|
|                       Mark Word(32bits)                           |  Klass Word(32bits)    |      State         |
|-----------------------------------------------------------------------------------------------------------------|
|     hashcode:25                      | age:4 | biased_lock:0 | 01 | OOP to metadata object |      Nomal         |
|-----------------------------------------------------------------------------------------------------------------|
|     thread:23              | epoch:2 | age:4 | biased_lock:1 | 01 | OOP to metadata object |      Biased        |
|-----------------------------------------------------------------------------------------------------------------|
|     ptr_to_lock_record:30                                    | 00 | OOP to metadata object | Lightweight Locked |
|-----------------------------------------------------------------------------------------------------------------|
|     ptr_to_heavyweight_monitor:30                            | 10 | OOP to metadata object | Heavyweight Locked |
|-----------------------------------------------------------------------------------------------------------------|
|                                                              | 11 | OOP to metadata object |    Marked for GC   |
|-----------------------------------------------------------------------------------------------------------------|

64位虚拟机对象头：

|-----------------------------------------------------------------------------------------------------------------|
|                                             Object Header(128bits)                                              |
|-----------------------------------------------------------------------------------------------------------------|
|                                   Mark Word(64bits)               |  Klass Word(64bits)    |      State         |
|-----------------------------------------------------------------------------------------------------------------|
|    unused:25|identity_hashcode:31|unused:1|age:4|biase_lock:0| 01 | OOP to metadata object |      Nomal         |
|-----------------------------------------------------------------------------------------------------------------|
|    thread:54|      epoch:2       |unused:1|age:4|biase_lock:1| 01 | OOP to metadata object |      Biased        |
|-----------------------------------------------------------------------------------------------------------------|
|                        ptr_to_lock_record:62                 | 00 | OOP to metadata object | Lightweight Locked |
|-----------------------------------------------------------------------------------------------------------------|
|                       ptr_to_heavyweight_monitor:62          | 10 | OOP to metadata object | Heavyweight Locked |
|-----------------------------------------------------------------------------------------------------------------|
|                                                              | 11 | OOP to metadata object |    Marked for GC   |
|-----------------------------------------------------------------------------------------------------------------|

lock:2位的锁状态标记位，由于希望用尽可能少的二进制位表示尽可能多的信息，所以设置了lock标记。该标记的值不同，整个mark word表示的含义不同。

biased_lock	lock	状态
0	01	无锁
1	01	偏向锁
0	00	轻量级锁
0	10	重量级锁
0	11	GC标记

biased_lock：对象是否启用偏向锁标记，只占1个二进制位。为1时表示对象启用偏向锁，为0时表示对象没有偏向锁。
age：4位的Java对象年龄。在GC中，如果对象在Survivor区复制一次，年龄增加1。当对象达到设定的阈值时，将会晋升到老年代。默认情况下，并行GC的年龄阈值为15，并发GC的年龄阈值为6。由于age只有4位，所以最大值为15，这就是-XX:MaxTenuringThreshold选项最大值为15的原因。
identity_hashcode：25位的对象标识Hash码，采用延迟加载技术。调用方法System.identityHashCode()计算，并会将结果写到该对象头中。当对象被锁定时，该值会移动到管程Monitor中。
thread：持有偏向锁的线程ID。
epoch：偏向时间戳。
ptr_to_lock_record：指向栈中锁记录的指针。
ptr_to_heavyweight_monitor：指向管程Monitor的指针。
 

monitor（锁）

monitor被翻译为监控器或管程，每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的 Mark Word 就被设置指向 Monitor 对象的指针

monitor的结构如下

 如上图所示

1. 当使用synchronized给对象上重量级锁之后，该对象头的mark word就被设置成指向monitor对象的指针
2. 而在monitor中的owner初始为nulll，当thread-2访问synchronized的时候，就会将monitor的所有者owner设置为thread-2，而一个monitor只能由一个owner
3. 在锁定的过程中如果thread-1、thread-3这时候也来执行synchronized代码块，就会进入entrylist中，变为阻塞状态
4. 当thread-2执行完代码块中的代码之后，就会清空owner的内容， 然后唤醒entrylist中的线程竞争锁，这个过程是不公平竞争

synchronized---轻量级锁

以下说的原理对使用者都是透明的，实际是jdk内部的自我优化，不需要人为进行操作，使用方法就跟平时一样加个synchronized

使用场景：如果一个对象虽然有很多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么就可以使用轻量级锁来优化

过程：

• 当线程访问synchronized锁的时候，创建锁记录（Lock Record）对象，每个线程的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的 Mark Word

• 让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录

• 如果 cas 替换成功，对象头中存储了 锁记录地址和状态 00 ，表示由该线程给对象加锁，这时图示如下

• 如果 cas 失败，有两种情况

1. 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程（后面介绍，类似锁升级）
2. 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数（下图所示）

 

• 当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一

• 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头

1. 成功，则解锁成功
2. 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

synchronized---锁膨胀

如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有 竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

• 当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁

• 这时 Thread-1 加轻量级锁失败，进入锁膨胀流程 ，即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址 ，然后自己进入 Monitor 的 EntryList BLOCKED

• 当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁 流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程

 synchronized---自旋优化

• 重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步 块，释放了锁），这时当前线程就可以避免阻塞。
• 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
• 在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会 高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。
• Java 7 之后不能控制是否开启自旋功能

自旋成功的情况

 自旋失败的情况

synchronized---偏向锁

• 轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。
• Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现 这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有

轻量级锁和偏向锁的区别

static final Object obj = new Object();
public static void m1() {
 synchronized( obj ) {
 // 同步块 A
 m2();
 }
}
public static void m2() {
 synchronized( obj ) {
 // 同步块 B
 m3();
 }
}
public static void m3() {
 synchronized( obj ) {

 // 同步块 C
 }
}

一个对象创建时：

• 如果开启了偏向锁（默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的 thread、epoch、age 都为 0
• 偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 VM 参数 -
• XX:BiasedLockingStartupDelay=0 来禁用延迟
• 如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、 age 都为 0，第一次用到 hashcode 时才会赋值

撤销偏向锁的方式

1、调用hashcode方法，因为调用hashcode的时候，会在mark word中加上hashcode的值，就没位置存储其他的偏向锁所需要的信息（thread、epoch等），所以就会取消偏向锁

2、其他线程使用对象时，会将偏向锁升级为轻量级锁

3、调用wait/notify，因为只有重量级锁才支持wait/notify，所以会进入重量级锁

4、通过-xx:-UseBiasedLocking 禁用偏向锁

批量重偏向

• 如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，重偏向会重置对象 的 Thread ID
• 当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至 加锁线程

代码演示：

 private static void test3() throws InterruptedException {
            Vector<Dog> list = new Vector<>();
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 30; i++) {
                    Dog d = new Dog();
                    list.add(d);
                    synchronized (d) {
                        log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                    }
                }
                synchronized (list) {
                    list.notify();
                }
            }, "t1");
            t1.start();

            Thread t2 = new Thread(() -> {
                synchronized (list) {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("===============> ");
                for (int i = 0; i < 30; i++) {
                    Dog d = list.get(i);
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                    synchronized (d) {
                        log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                    }
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                }
            }, "t2");
            t2.start();
        }

输出：

[t1] - 0 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 1 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 2 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 3 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 4 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 5 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 6 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 7 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 8 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 9 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 10 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 11 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 12 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 13 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 14 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 15 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 16 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 17 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 18 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - ===============> 
[t2] - 0 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 0 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 0 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 1 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 1 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 1 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 2 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 2 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 2 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 3 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 3 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 3 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 4 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 4 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 4 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 5 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 5 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 5 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 6 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 6 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 6 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 7 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 7 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 7 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 8 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 8 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 8 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 9 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 9 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 9 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 10 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 10 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 10 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 11 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 11 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 11 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 12 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 12 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 12 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 13 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 13 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 13 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 14 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 14 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 14 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 15 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 15 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 15 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 16 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 16 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 16 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 17 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 17 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 17 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 18 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 18 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 18 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101

批量撤销

• 当撤销偏向锁阈值超过 40 次后，jvm 会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象 都会变为不可偏向的，新建的对象也是不可偏向的

锁消除

• java中有一个JIT（即时编译器），对于一些热点数据就会通过JIT对java字节码进行进一步优化，其中一个手段就是看看局部变量是否能优化，当发现局部变量不会逃离方法的作用范围的时候（数据不可能被共享),这时候加synchronized锁就无意义了，此时JIT就会将synchronized优化掉，真正执行中是不走synchronized这一行代码的，只执行了方法区的内容，这就叫做锁消除

ReentrantLock 

特点：

• 可中断
• 可以设置超时时间
• 可设置为公平锁
• 支持多个条件变量
• 可重入

基本使用代码演示：

// 获取锁
reentrantLock.lock();
try {
 // 临界区
} finally {
 // 释放锁
 reentrantLock.unlock();
}

可重入性代码演示：

 static ReentrantLock lock = new ReentrantLock();
        public static void main(String[] args) {
            method1();
        }
        public static void method1() {
            lock.lock();
            try {
                log.debug("execute method1");
                method2();
            } finally {
                lock.unlock();
            }
        }
        public static void method2() {
            lock.lock();
            try {
                log.debug("execute method2");
                method3();
            } finally {
                lock.unlock();
            }
        }
        public static void method3() {
            lock.lock();
            try {
                log.debug("execute method3");
            } finally {
                lock.unlock();
            }
}

输出

17:59:11.862 [main] c.TestReentrant - execute method1

17:59:11.865 [main] c.TestReentrant - execute method2

17:59:11.865 [main] c.TestReentrant - execute method3

可打断性代码演示

        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            log.debug("启动...");
            try {
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.debug("等锁的过程中被打断");
                return;
            }
            try {
                log.debug("获得了锁");
            } finally {
                lock.unlock();
            }
        }, "t1");
        lock.lock();
        log.debug("获得了锁");
        t1.start();
        try {
            sleep(1);
            t1.interrupt();
            log.debug("执行打断");
        } finally {
            lock.unlock();
        }

输出：

18:02:40.520 [main] c.TestInterrupt - 获得了锁

18:02:40.524 [t1] c.TestInterrupt - 启动 ...

18:02:41.530 [main] c.TestInterrupt - 执行打断

java.lang.InterruptedException

atjava.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchr onizer.java:898) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchron

izer.java:1222)

at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)

at cn.itcast.n4.reentrant.TestInterrupt.lambda$main$0(TestInterrupt.java:17)

at java.lang.Thread.run(Thread.java:748)

18:02:41.532 [t1] c.TestInterrupt - 等锁的过程中被打断

尝试获取锁，获取失败立即停止获取

 ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            log.debug("启动...");
            if (!lock.tryLock()) {
                log.debug("获取立刻失败，返回");
                return;
            }
            try {
                log.debug("获得了锁");
            } finally {
                lock.unlock();
            }
        }, "t1");
        lock.lock();
        log.debug("获得了锁");
        t1.start();
        try {
            sleep(2);
        } finally {
            lock.unlock();
        }

设置超时时间，尝试获取锁，如果超过超时时间还没获取就停止获取

 ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            log.debug("启动...");
            try {
                if (!lock.tryLock(1, TimeUnit.SECONDS)) {
                    log.debug("获取等待 1s 后失败，返回");
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                log.debug("获得了锁");
            } finally {
                lock.unlock();
            }
        }, "t1");
        lock.lock();
        log.debug("获得了锁");
        t1.start();
        try {
            sleep(2);
        } finally {
            lock.unlock();
        }

公平锁

ReentrantLock默认是不公平锁，就是当锁被占用之后，其他线程要获取锁就会进入阻塞队列，当锁被释放后，阻塞队列内多个线程就是竞争锁，不会按照顺序获得锁

设置公平锁只需要在创建对象的时候传入一个true，默认是false

ReentrantLock lock = new ReentrantLock ( true );

条件变量：

支持多个等待区

await 前需要获得锁

await 执行后，会释放锁，进入 conditionObject 等待

await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁

竞争 lock 锁成功后，从 await 后继续执行

通过signal或singalall唤醒

代码演示：

  static ReentrantLock lock = new ReentrantLock();
        static Condition waitCigaretteQueue = lock.newCondition();
        static Condition waitbreakfastQueue = lock.newCondition();
        static volatile boolean hasCigrette = false;
        static volatile boolean hasBreakfast = false;
        public static void main (String[]args){
            new Thread(() -> {
                try {
                    lock.lock();
                    while (!hasCigrette) {
                        try {
                            waitCigaretteQueue.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    log.debug("等到了它的烟");
                } finally {
                    lock.unlock();
                }
            }).start();
            new Thread(() -> {
                try {
                    lock.lock();
                    while (!hasBreakfast) {
                        try {
                            waitbreakfastQueue.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    log.debug("等到了它的早餐");
                } finally {
                    lock.unlock();
                }
            }).start();
            sleep(1);
            sendBreakfast();
            sleep(1);
            sendCigarette();
        }
        private static void sendCigarette () {
            lock.lock();
            try {
                log.debug("送烟来了");
                hasCigrette = true;
                waitCigaretteQueue.signal();
            } finally {
                lock.unlock();
            }
        }
        private static void sendBreakfast () {
            lock.lock();
            try {
                log.debug("送早餐来了");
                hasBreakfast = true;
                waitbreakfastQueue.signal();
            } finally {
                lock.unlock();
            }

读写锁ReentrantReadWriteLock

支持锁降级，不支持锁升级，读读并发，读写互斥

   class CachedData {
            Object data;
            // 是否有效，如果失效，需要重新计算 data
            volatile boolean cacheValid;
            final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
            void processCachedData() {
                rwl.readLock().lock();
                if (!cacheValid) {
                    // 获取写锁前必须释放读锁
                    rwl.readLock().unlock();
                    rwl.writeLock().lock();
                    try {
                        // 判断是否有其它线程已经获取了写锁、更新了缓存, 避免重复更新
                        if (!cacheValid) {
                            data = ...
                            cacheValid = true;
                        }
                        // 降级为读锁, 释放写锁, 这样能够让其它线程读取缓存
                        rwl.readLock().lock();
                    } finally {

                        rwl.writeLock().unlock();
                    }
                }
                // 自己用完数据, 释放读锁 
                try {
                    use(data);
                } finally {
                    rwl.readLock().unlock();
                }
            }

stampedLock

实现乐观读，读取数据后，在返回数据前校验戳，如果戳改变了，升级为读锁再次读取数据

class DataContainerStamped {
            private int data;
            private final StampedLock lock = new StampedLock();
            public DataContainerStamped(int data) {
                this.data = data;
            }
            public int read(int readTime) {
                long stamp = lock.tryOptimisticRead();
                log.debug("optimistic read locking...{}", stamp);
                sleep(readTime);
                if (lock.validate(stamp)) {
                    log.debug("read finish...{}, data:{}", stamp, data);
                    return data;
                }
                // 锁升级 - 读锁
                log.debug("updating to read lock... {}", stamp);
                try {
                    stamp = lock.readLock();
                    log.debug("read lock {}", stamp);
                    sleep(readTime);
                    log.debug("read finish...{}, data:{}", stamp, data);
                    return data;
                } finally {
                    log.debug("read unlock {}", stamp);
                    lock.unlockRead(stamp);
                }
            }
            public void write(int newData) {
                long stamp = lock.writeLock();
                log.debug("write lock {}", stamp);
                try {
                    sleep(2);
                    this.data = newData;
                } finally {
                    log.debug("write unlock {}", stamp);
                    lock.unlockWrite(stamp);
                }
            }
        }