Serendipity sn

四万字长文总结多线程，一篇就够了！

多线程

多线程
- 1.认识线程及线程的创建
- - <1>.线程的概念
  - <2>.线程的特性
  - <3>.线程的创建方式
  - - (1)继承Thread类
    - (2)实现Runnable接口
    - (3)实现Callable接口
- 2.线程的常用方法
- - <1>构造方法和属性的获取方法
  - <2>常用方法
  - - (1)run()和 start()
    - (2)interrupt()方法
    - (3)join方法
    - (4)获取当前线程的引用currentThread();方法
    - (5)休眠当前线程sleep();方法
    - (6)线程让步yield();方法
- 3.线程的生命周期和状态转换
- 4.线程间的通信
- 5.多线程的安全及解决
- - <1>原子性
  - <2>可见性
  - <3>代码的顺序性
  - <4>线程不安全问题的解决
  - - (1)synchronized 关键字
    - (2)volatile 关键字
- 6.锁体系
- - <1>Synchronized加锁方式
  - - (1)<1>Synchronized的加锁方式及语法基础
    - (2)Synchronized的原理及实现
    - (3)JVM对Synchronized的优化
    - - 1)对锁的优化
      - 2)锁粗话
      - 3)锁消除
  - <2>常见的锁策略及CAS
  - - (1)乐观锁和悲观锁
    - (2)自旋锁
    - (3)可重入锁
  - <3>Lock体系
  - - (1)Lock接口
    - - 1)使用Lock锁实现线程同步
      - 2)Lock加锁的四种方式
    - (2)AQS简单认识
    - (3)ReentrantLock
    - - 1)ReentrantLock基本概念
      - 2）自己实现一个简单的ReentrantLock
      - 3）ReentrantLock部分源码分析
      - 4)ReadWriteLock锁
  - <4>.Lock锁和同步锁（synchronized）的区别与对比
  - <5>死锁
- 7.多线程案例
- - <1>生产者消费者问题
  - <2>单例模式
  - <3>阻塞式队列
  - <4>线程池
- 8.JUC包
- - <1>Semaphore(信号量 )
  - <2>CountDownLatch
  - <3>CyclicBarrier(循环栅栏)
  - <4>ConcurrentHashMap
  - - (1)ConcurrentHashMap加锁方式
    - (2)fail-fast和fail-safe
- 9.ThreadLocal
- - <1>基础API
  - <2>ThreadLocal和synchronized的区别
  - <3>ThreadLocal的内部结构
  - <4>ThrealLocal内存泄漏
- 10.Java多线程相关面试题
- - <1>、volatile、ThreadLocal的使用场景和原理；
  - <2>、ThreadLocal什么时候会出现OOM的情况？为什么？
  - <3>、synchronized、volatile区别
  - <4>ThreadLocal的作用以及为什么发生内存泄漏和解决方法
  - <5>.如何中断一个线程

1.认识线程及线程的创建

<1>.线程的概念

线程和进程的区别：
进程是系统分配资源的最小单位，线程是系统调度的最小单位。
一个进程内的线程之间是可以共享资源的。
每个进程至少有一个线程存在，即主线程。

注：
每个进程至少有一个线程存在，即主线程（系统级别的，C语言的主线程）
java级别的主线程（自己写的入口函数main方法（可以没有这个线程）
对java进程来说，至少有一个非守护线程还没终止，进程就不会结束

<2>.线程的特性

在后面线程的安全性会详细介绍
1.原子性：即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
2.可见性：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
3.有序性：程序执行的顺序按照代码的先后顺序执行。

<3>.线程的创建方式

(1)继承Thread类

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("继承Thread类创建线程");
    }
}
 public static void main(String[] args) {
        //1.继承Thread类创建线程
        MyThread t=new MyThread();
        t.start();
        }

(2)实现Runnable接口

将MyRunnable对象作为任务传入Thread中

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("继承Runnable接口，创建描述任务对象，实现多线程");
    }
}
  public static void main(String[] args) {
     
        //2.实现Runnable接口
        Thread t1=new Thread(new MyRunnable());
        t1.start();
        }

2.使用匿名内部类实现

 Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("使用Runnable接口，创建匿名内部类实现");
            }
        });
        t2.start();

(3)实现Callable接口

实现Callable重现call方法，允许抛出异常，允许带有返回值，返回数据类型为接口上的泛型

class MyCallable implements Callable<String> {
    //允许抛出异常，允许带有返回值，返回数据类型为接口上的泛型
    @Override
    public String call() throws Exception {
        System.out.println("实现了Callable接口");
        return "这不是一个线程类，而是一个任务类";
    }
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
        //方法三：实现Callable接口,是一个任务类
        //FutureTask底层也实现了Runnable接口
        FutureTask<String> task=new FutureTask<>(new MyCallable());
        new Thread(task).start();
        System.out.println(task.get());
    }

2.线程的常用方法

<1>构造方法和属性的获取方法

构造方法：

属性的获取方法：

<2>常用方法

(1)run()和 start()

start();方法:启动线程
run();方法:覆写 run 方法是提供给线程要做的事情的指令清单

start()和run()的区别：见代码

public class Thread_Run_VS_Start {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){

                }
            }
        }).run();
        /**
         * main线程直接调用Thread对象的run方法会直接在main线程
         * 运行Thread对象的run（）方法---->传入的runnable对象.run（）
         * 结果，main线程直接运行while（true）
         *
         * start()是启动一个线程，调用新线程的while（true）方法
         * 对比通过start（）调用的结果区别
         */

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){

                }
            }
        }).start();
    }
}

(2)interrupt()方法

通过interrupt()方法,通知线程中的中断标志位,由false变为true,但是线程什么时候中断,需要线程自己的代码实现
通过线程中的中断标志位实现,比起自己手动设置中断标志位,可以避免线程处于阻塞状态下,无法中断的情况

对interrupt，isInterrupt，interrupted的理解：
实例方法：
（1）interrupt：置线程的中断状态
如果调用该方法的线程处于阻塞状态（休眠等），会抛出InterruptedException异常
并且会重置Thread.interrupted;返回当前标志位，并重置
（2）isInterrupt：线程是否中断,返回boolean
静态方法：
（3）interrupted：返回线程的上次的中断状态，并清除中断状

public class Interrupt {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {

                //...执行任务，执行时间可能比较长
               //运行到这里，在t的构造方法中不能引用t使用Thread.currentThread()方法，获取当前代码行所在线程的引用
                for (int i = 0; i <10000&&!Thread.currentThread().isInterrupted() ; i++) {
                    System.out.println(i);
                    //模拟中断线程
                    try {
                        Thread.sleep(1000);
                        //通过标志位自行实现，无法解决线程阻塞导致无法中断
                        //Thread,sleep(100000)
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();//线程启动，中断标志位=false
        System.out.println("t start");
        //模拟，t执行了5秒，进程没有结束，要中断，停止t线程
        Thread.sleep(5000);

        //未设置时，isInterrupt为false

        //如果t线程处于阻塞状态（休眠等），会抛出InterruptedException异常
        //并且会重置isInterrupt中断标志位位false
        t.interrupt();//告诉t线程，要中断（设置t线程的中断标志位为true），由t的代码自行决定是否要中断
        //isInterrupt设置为true
        //t.isInterrupted();  Interrupted是线程中的标志位
        System.out.println("t stop");


        //注：Thread.interrupted(); 返回当前线程的中断标志位，然后重置中断标志位
         
    }
}

(3)join方法

注意: join方法是实例方法
等待一个线程执行完毕,才执行下一个线程（调用该方法的线程等待

无参：t.join：当前线程无条件等待，直到t线程运行完毕

有参：t.join(1000)等待1秒，或者t线程结束，哪个条件满足，当前线程继续往下执行

//join方法：实例方法：
// 1.无参：t.join：当前线程无条件等待，直到t线程运行完毕
//  2.有参：t.join(1000)等待1秒，或者t线程结束，哪个条件满足，当前线程继续往下执行
public class Join {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("1");
            }
        });
        t.start();

        t.join();//当前线程main线程无条件等待，直到t线程执行完毕，当前线程再往后执行
       // t.join(1000);当前线程等到1秒，或者等t线程执行完毕
        System.out.println("ok");

    }
}

(4)获取当前线程的引用currentThread();方法

静态方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ud5ACR7u-1628311316793)(C:\Users\26905\AppData\Roaming\Typora\typora-user-images\image-20210709001304951.png)]

    public class ThreadDemo { 
    public static void main(String[] args) { 
    Thread thread = Thread.currentThread(); 
    System.out.println(thread.getName()); 
     } 
    }

(5)休眠当前线程sleep();方法

让线程等待一定时间后,继续运行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y6l240R4-1628311316794)(C:\Users\26905\AppData\Roaming\Typora\typora-user-images\image-20210709001410719.png)]

Thread.sleep(1000);

(6)线程让步yield();方法

让yield();所在代码行的线程让步,当其他线程先执行

public class Yield {
    public static void main(String[] args) {
        for(int i=0;i<20;i++){
            final int n=i;
            Thread t=new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(n);
                }
            });
            t.start();
        }
        //判断：如果活跃的线程数量大于1，main线程让步
        while (Thread.activeCount()>1){//记录活跃线程的数量
            Thread.yield();
        }//注意：要用debug方式，因为run方式，idea后台还会启动一个线程
        //实现ok在1到二十之后打印
        System.out.println("ok");
    }
}

3.线程的生命周期和状态转换

Java 语言中线程共有六种状态，分别是：

NEW(初始化状态)

RUNNABLE(可运行 / 运行状态)

BLOCKED(阻塞状态)

WAITING(无时限等待)

TIMED_WAITING(有时限等待)

TERMINATED(终止状态)

生命周期和状态转换图：

常见的API导致的状态转换：
1.线程的阻塞：
Thread.sleep(long);当前线程休眠
t.join/t.join(long);t线程加入当前线程，当前线程等待阻塞
synchronized:竞争对象锁失败的线程，进入阻塞态
2.线程的启动：
start() ----->注意：run（）只是任务的定义，start（）才是启动

3.线程的中断：interrupt让某个线程中断，不是直接停止线程，而是一个“建议”，是否中断，由线程代码自己决定

4.线程间的通信

wait(0方法:线程等待
notify();方法:随机唤醒一个线程
notifyAll():方法:唤醒所有等待的线程
注意:这三个方法都需要被Synchronized包裹x

线程间通信的案例:
有三个线程，每个线程只能打印A，B或C
要求：同时执行三个线程，按ABC顺序打印，依次打印十次
ABC换行 ABC换行。。。。

public class SequencePrintHomeWork {
    //有三个线程，每个线程只能打印A，B或C
    //要求：同时执行三个线程，按ABC顺序打印，依次打印十次
    //ABC换行 ABC换行。。。。
    //考察知识点：代码设计，多线程通信

    public static void main(String[] args) {
        Thread a = new Thread(new Task("A"));
        Thread b = new Thread(new Task("B"));
        Thread c = new Thread(new Task("C"));
        c.start();
        b.start();
        a.start();
    }

    private static class Task implements Runnable{

        private String content;
        //顺序打印的内容：可以循环打印
        private static String[] ARR = {"A", "B", "C"};
        private static int INDEX;//从数组哪个索引打印

        public Task(String content) {
            this.content = content;
        }

        @Override
        public void run() {
            try {
                for(int i=0; i<10; i++){
                    synchronized (ARR){//三个线程使用同一把锁
                        //从数组索引位置打印，如果当前线程要打印的内容不一致，释放对象锁等待
                        while(!content.equals(ARR[INDEX])){
                            ARR.wait();
                        }
                        //如果数组要打印的内容和当前线程要打印的一致，
                        // 就打印，并把数组索引切换到一个位置，通知其他线程
                        System.out.print(content);
                        if(INDEX==ARR.length-1){
                            System.out.println();
                        }
                        INDEX = (INDEX+1)%ARR.length;
                        ARR.notifyAll();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

补充： wait（）和sleep（）的区别：

wait 之前需要请求锁，而wait执行时会先释放锁，等被唤醒时再重新请求锁。这个锁是 wait 对象上的 monitor
lock
sleep 是无视锁的存在的，即之前请求的锁不会释放，没有锁也不会请求。
wait 是 Object 的方法
sleep 是 Thread 的静态方法

5.多线程的安全及解决

<1>原子性

对原子性的理解： 我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还没有出来；B 是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。
注意： 一条 java 语句不一定是原子的，也不一定只是一条指令
例如：

如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错

<2>可见性

为了提高效率，JVM在执行过程中，会尽可能的将数据在工作内存中执行，但这样会造成一个问题，共享变量在多线程之间不能及时看到改变，这个就是可见性问题。

可见性：
系统调度CPU执行线程内，某个方法，产生CPU视角的主存，工作内存
主存：线程共享
工作内存：线程私有内存+CPU高速缓存/寄存器
对主存中共享数据的操作，存在主存到工作内存<====>从主存读取,工作内存修改,写回主存(拷贝)

<3>代码的顺序性

代码的重排序:
一段代码:
1.去前台取下 U 盘
2. 去教室写 10 分钟作业
3. 去前台取下快递
如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按 1->3->2的方式执行，也是没问题，可以少跑一次前台。这种叫做指令重排序

代码重排序会给多线程带来什么问题:
刚才那个例子中，单线程情况是没问题的，优化是正确的，但在多线程场景下就有问题了，什么问题呢。可能快递是在你写作业的10分钟内被另一个线程放过来的，或者被人变过了，如果指令重排序了，代码就会是错误的。

<4>线程不安全问题的解决

(1)synchronized 关键字

这里会在下面锁体系中详细说

(2)volatile 关键字

volatile 关键字的作用：
(1)保证可见性
(2)禁止指令重排序，建立内存屏障——单例模式说明
(3)不保证原子性
常见的使用场景：一般是读写分离的操作，提高性能
(1)写操作不依赖共享变量，赋值是一个常量（依赖共享变量的赋值不是原子性操作）
(2)作用在读，写依赖其他手段（加锁）

一个volatile的简单例子：

public class Test {
    private static boolean flag = true;
    public static void main(String[] args) {
        //创建一个线程并启动
        new Thread(new Runnable() {
            int i=0;
            @Override
            public void run() {
                while(flag){
                    //这个语句底层使用了synchronized，保证了可见性
                    //System.out.println("=============");

                    i++;
                }
            }
        }).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //即使改了，上面的线程flag也不会改，会一直循环
        flag = false;
    }
}

6.锁体系

多线程中锁的作用：保证线程的同步

<1>Synchronized加锁方式

(1)<1>Synchronized的加锁方式及语法基础

如何解决上述原子性例子的问题:
是不是只要给房间加一把锁，A 进去就把门锁上，其他人是不是就进不来了。这样就保证了这段代码的原子性了。有时也把这个现象叫做同步互斥，表示操作是互相排斥的。
synchronized 关键字:
(1)作用:对一段代码进行加锁操作,让某一段代码满足三个特性:原子性,可见性,有序性
(2)原理:多个线程间同步互斥(一段代码在任意一个时间点,只有一个线程执行:加锁,释放锁)
注意: 加锁/释放锁是基于对象来进行加锁和释放锁,不是把代码锁了

只有对同一个对象加锁,才会让线程产生同步互斥的效果:
那么怎样才叫对同一个对象加锁呢？
这里t代表类名，t1，t2是 new了两个t increment是t中的一个方法（是静态还是实例具体看）

synchronized处加锁，抛出异常或代码块结束释放锁

具体过程：

synchronized 多个线程n同步互斥:
(1):一个时间只有一个线程执行(同步互斥)
(2):竞争失败的线程,不停的在阻塞态和运行态切换(用户态和内核态切换)
(3)同步线程数量越多,性能越低

一个简单的小例子：

public class SafeThread {
    //有一个遍历COUNT=0；同时启动20个线程，每个线程循环1000次，每次循环把COUNT++
    //等待二十个子线程执行完毕之后，再main中打印COUNT的值
    //（预期）count=20000
    private static int COUNT=0;

    //对当前类对象进行加锁，线程间同步互斥
//    public synchronized static void increment(){
//        COUNT++;
//    }


    //使用不同的对象加锁，没有同步互斥的效果，并发并行
//    public static void increment(){
//        synchronized (new SafeThread()){
//            COUNT++;
//        }
//    }
    public static void main(String[] args) throws InterruptedException {
        //尽量同时启动，不让new线程操作影响
        Class clazz=SafeThread.class;
      Thread[]threads=new Thread[20];
        for (int i = 0; i <20 ; i++) {
            threads[i]=new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j <1000 ; j++) {
                        //给SafeThread对象加一把锁
                        synchronized (clazz){
                            COUNT++;
                        }
                    }
                }
            });
        }
        for (int i = 0; i <20 ; i++) {
            threads[i].start();
        }

        //让main线程等待20个子线程运行完毕
        for (int i = 0; i <20 ; i++) {
            threads[i].join();
        }

        System.out.println(COUNT);
    }
}

synchronized加锁的缺点：
a)如果获取锁的线程由于要等待IO或其他原因（如调用sleep方法）被阻塞了，但又没有释放锁，其他线程只能干巴巴地等待，此时会影响程序执行效率。
b)只要获取了synchronized锁，不管是读操作还是写操作，都要上锁，都会独占。如果希望多个读操作可以同时运行，但是一个写操作运行，无法实现。

(2)Synchronized的原理及实现

1.Monitor机制：
（1）基于monitor对象的监视器：使用对象头的锁状态来加锁
（2）编译为字节码指令为：1个monitoren+2个monitorexit
多出来的一个monitorexit：如果出现异常，第一个monitorexit无法正确释放锁，这个monitorexit进行锁释放

例如下列代码：

public class Test1 {
    public Test1() {
    }

    public static void main(String[] args) {
        Class var1 = Test1.class;
        synchronized(Test1.class) {
            System.out.println("hello");
        }
    }
}

反编译：

（3）monitor存在计数器实现synchronized的可重入性：进入+1，退出-1；

(3)JVM对Synchronized的优化

1)对锁的优化

Synchronized是基于对象头的锁状态来实现的，从低到高：（锁只能升级不能降级）
（1）无锁
（2）偏向锁：对同一个对象多次加锁（重入）
（3）轻量级锁：基于CAS实现，同一个时间点，经常只有一个线程竞争锁
（4）重量级锁：基于系统的mutex锁，同一个时间点，经常有多个线程竞争
特点：mutex是系统级别的加锁，线程会由用户态切换到内核态，切换的成本比较高（一个线程总是竞争失败，就会不停的在用户态和内核态之间切换，比较耗费资源，进一步，如果很多个竞争失败的线程，性能就会有很大的影响）

2)锁粗话

多个synchronized连续执行加锁，释放锁，可以合并为一个
示例：StringBuffer静态变量，在一个线程中多次append（静态变量属于方法区，jdk 1.8后是在堆里面，线程共享）

public class Test {
    private static StringBuffer sb;
    public static void main(String[] args) {
        sb.append("1").append("2").append("3");
    }
}

3)锁消除

对不会逃逸到其他线程的变量，执行加锁的操作，可以删除加锁
示例：StringBuffer局部变量，在一个线程中多次append（局部变量属于虚拟机栈，是线程私有的）

public class Test {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer();
        sb.append("1");
        sb.append("2");
        sb.append("3");
    }
}

<2>常见的锁策略及CAS

多线程中锁类型的划分：
API层面：synchronized加锁 Lock加锁
锁的类型：偏向锁，轻量级锁，重量级锁，自旋锁，独占锁，共享锁，公平锁，非公平锁等等

(1)乐观锁和悲观锁

乐观锁和悲观锁的设计思想（和语言是无关的，不是java多线程独有的）
根据使用常见来阐述：
乐观锁：同一个时间点，经常只有一个线程来操作共享变量，适合使用乐观锁
悲观锁：同一个时间点，经常有多个线程来操作共享变量，适合使用悲观锁

乐观锁的实现原理：
通过直接操作共享变变量（不会阻塞），通过调用的api的返回值，来知道操作是成功还是失败的
java多线程的实现：基于CAS的方式实现（Compare and Swap）
令：主存中需要操作的变量为V，线程A的工作内存中，读入A，修改为N
有另一个线程可能对主存中的V进行操作
此时：新的主存中操作的变量令为O，比较线程A中的V和此时主存中的O是否相等，如果相等，说明可以将N写回主存，如果不相等，任务主存中的变量被B线程操作过，此时A中的N不写入主存，线程A不做任何事情。

悲观锁的实现原理：类似于synchronized加锁方式

**CAS中可能存在的问题（ABA问题） **
肯主存中原来的V值，被线程B加一，再减一，依然满足上述线程A可以写入N的条件
解决办法：为主存中的变量加上一个版本好，在上诉A线程可写入的基础上，再比较一次版本好。即可解决。

CAS在java中是使用unsafe类来完成的，本质上是基于CPU提供的对变量原子性线程安全的修改操作

(2)自旋锁

按照普通加锁的方式处理，当线程在抢锁失败之后会进入阻塞状态，放弃CPU，需要经过很久才能被再次调度，所以，引入读写锁，当锁竞争失败之后，只需要很短时间，锁就能再次被释放，此时，让竞争失败的线程，进入自旋，不在用户态和内核态之间切换。只要没抢到锁，就死等。
类似以下代码：

<1>.无条件的自选：

while(抢锁(lock)==失败{}

自旋锁的缺陷：如果之前的假设（锁很快就能被释放）没有满足，那么进入自旋的线程就一直在消耗CPU的资源，长期在做无用功

<2>.有条件的自旋：
如可中断的自旋：自旋时线程判断中断标志位后再执行，或者限制自旋的次数，限制自旋的时间

自旋锁，悲观乐观锁，CAS的总结：
<1>.悲观锁是线程先加锁，之后再修改变量的操作
<2>.乐观锁是线程直接尝试修改变量（不会阻塞）。在java多线程中是基于CAS 实现的。
<3>.CAS
概念：Compare and Swap比较并交换
实现/原理：基于unsafe来实现，本质上是基于CPU提供的接口保证线程安全修改变量。
使用（V,O,N）：V为内存地址中存放的实际值，O为预期的值（旧值），N为更新的值（新值）
可能出现的问题：ABA问题（引入版本号解决）
<4>.自旋+CAS
适用的场景：同一个时间点，常常只有一个线程进行操作
不适应的场景：1.同一个时间点，常常有多个线程进行操作
2.CAS的操作时间时间太长，给了其他线程操作共享变量的机会，那么CAS的成功率会很低，经常做无用功

自旋的缺陷：线程一直处于运行态，会很耗费CPU的资源

(3)可重入锁

允许同一个线程多次获取同一把锁
java中只要以Reentrant开头命名的锁都是可重入的锁，现有的jdk提供的lock的实现类和synchronized加锁,都是可重入锁
例如：

public class Test2 {
    public static synchronized void t1(){
        t2();
    }
    public static synchronized void t2(){

    }
    public static void main(String[] args) {
        t1();
    }
}

<3>Lock体系

(1)Lock接口

1)使用Lock锁实现线程同步

上代码！

public class AccountRunnable implements  Runnable {
    private Account account = new Account();
    //买一把锁
    Lock lock = new ReentrantLock(); //Re-entrant-Lock  可重入锁
    @Override
    public void run() {
        //此处省略300句
        try{
//上锁
            lock.lock();
            //判断余额是否足够，够，取之；不够，不取之；
            if(account.getBalance()>=400){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                method1();
                //取之
                account.withDraw(400);
                //输出信息
                System.out.println(Thread.currentThread().getName()+
                   "取款成功，现在的余额是"+account.getBalance());
            }else{
                 System.out.println("余额不足，"+Thread.currentThread().getName()
                 +"取款失败，现在的余额是"   +account.getBalance());
            }
        }finally {
            //解锁
            lock.unlock();
        }
        //此处省略100句
    }
}

这里要注意：释放锁时，要考虑是否出现异常，和上面synchronized加锁相同，要进行两次锁释放，这里将锁放在finally代码块中

2)Lock加锁的四种方式

形象记忆：男生追女生

1.lock():一直表白，直到成功
lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

2.tryLock():表白一次，失败就放弃
tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。拿不到锁时不会一直在那等待。

3.tryLock(long time, TimeUnit unit) 在一定的时间内持续表白，如果时间到了则放弃
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

4.lockInterruptibly()　　一直表白，当被通知她有男朋友了，才放弃
lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当这个线程使用lockInterruptibly()获取锁，当被interrupt中断时，才会停止竞争锁

(2)AQS简单认识

AQS： AbstractQuenedSynchronizer抽象的队列式同步器。是除了java自带的synchronized关键字之外的锁机制。这个类在java.util.concurrent.locks包.

AQS的核心思想是: 如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

AQS的实现方式：

如图示，AQS维护了一个volatile int state和一个FIFO线程等待队列，多线程争用资源被阻塞的时候就会进入这个队列。state就是共享资源

AQS 定义了两种资源共享方式：
1.Exclusive：独占，只有一个线程能执行，如ReentrantLock
2.Share：共享，多个线程可以同时执行，如Semaphore、CountDownLatch、ReadWriteLock，CyclicBarrier

(3)ReentrantLock

1)ReentrantLock基本概念

ReentrantLock，意思是“可重入锁”。ReentrantLock是唯一实现了Lock接口的非内部类，并且ReentrantLock提供了更多的方法。
ReentrantLock锁在同一个时间点只能被一个线程锁持有。
ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下，线程依次排队获取锁；而“非公平锁”在锁是可获取状态时，不管自己是不是在队列的开头都会获取锁。

当单个线程或线程交替执行时，他与队列无关，只会在jdk级别解决，性能高

2）自己实现一个简单的ReentrantLock

原理：自旋+park–unpark+CAS

public class Test2 {
    volatile int status=0;
    Queue parkQueue;//集合 数组  list
    void lock(){
        while(!compareAndSet(0,1)){
            //这里不能用sleep或yield实现
            //sleep无法确定睡眠的时间
            //yield只能用于两个线程竞争，当有多个线程之后，t1抢不到锁，yield会让出cpu，但是可能下一次cpu还是调t1
            park();
        }
        unlock();
    }
    void unlock(){
        lock_notify();
    }
    void park(){
        //将当期线程加入到等待队列
        parkQueue.add(currentThread);
        //将当期线程释放cpu  阻塞   睡眠
        releaseCpu();
    }
    void lock_notify(){
        //status=0
        //得到要唤醒的线程头部线程
        Thread t=parkQueue.header();
        //唤醒等待线程
        unpark(t);
    }
}

3）ReentrantLock部分源码分析

ReentrantLock锁分为公平锁和非公平锁（创建不加参数时默认非公平锁）

ReentrantLock提供了两个构造器：

//非公平锁
 public ReentrantLock() {
        sync = new NonfairSync();
    }
//公平锁
 public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

ReentrantLock的lock方式：

非公平锁：
调用lock方法：

final void lock() {
    if (compareAndSetState(0, 1))//首先用一个CAS操作，判断state是否是0（表示当前锁未被占用）
        setExclusiveOwnerThread(Thread.currentThread());//设置当前占有锁的线程为该线程
    else
        acquire(1);
}

首先用一个CAS操作，判断state是否是0（表示当前锁未被占用），如果是0则把它置为1，并且设置当前线程为该锁的独占线程，表示获取锁成功。当多个线程同时尝试占用同一个锁时，CAS操作只能保证一个线程操作成功，剩下的只能乖乖的去排队。
“非公平”即体现在这里，如果占用锁的线程刚释放锁，state置为0，而排队等待锁的线程还未唤醒时，新来的线程就直接抢占了该锁，那么就“插队”了。

下面说说acquire的过程

public final void acquire(int arg) {
    //首先看看自己要不要排队，如果不用排队，获取锁，要排队，加入AQS队列 
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

(1)尝试去获取锁（看看自己要不要排队）
非公平锁tryAcquire的流程是：检查state字段，若为0，表示锁未被占用，那么尝试占用，若不为0，检查当前锁是否被自己占用，若被自己占用，则更新state字段，表示重入锁的次数。如果以上两点都没有成功，则获取锁失败，返回false。

tryAcquire(arg)
final boolean nonfairTryAcquire(int acquires) {
    //获取当前线程
    final Thread current = Thread.currentThread();
    //获取state变量值
    int c = getState();
    if (c == 0) { //没有线程占用锁
        if (compareAndSetState(0, acquires)) {
            //占用锁成功,设置独占线程为当前线程
            setExclusiveOwnerThread(current);
            return true;
        }
    } else if (current == getExclusiveOwnerThread()) { //当前线程已经占用该锁 重入锁
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 更新state值为新的重入次数
        setState(nextc);
        return true;
    }
    //获取锁失败
    return false;
}

(2)入队
根据java运算符短路，如果不需要排队，方法直接返回，如果需要排队，进入addWaiter方法

公平锁：
公平锁和非公平锁不同之处在于，公平锁在获取锁的时候，不会先去检查state状态，而是直接执行aqcuire(1）

4)ReadWriteLock锁

ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public   interface   ReadWriteLock { 
      Lock readLock();   
      Lock writeLock(); 
}

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。
ReadWriteLock是一个接口，ReentrantReadWriteLock是它的实现类，该类中包括两个内部类ReadLock和WriteLock，这两个内部类实现了Lock接口。

认识ReadWriteLock锁

public class TestLock {
    public static void main(String[] args) {
//默认也是非公平锁  也是可重入锁
        ReadWriteLock rwl = new ReentrantReadWriteLock();
        //多次返回的都是同一把读锁 同一把写锁
        Lock readLock = rwl.readLock();
        Lock readLock2 = rwl.readLock();
        Lock writeLock = rwl.writeLock();
        readLock.lock();
        readLock.unlock();
        System.out.println(readLock==readLock2);
    }
}

注意：从结果中看到，从一个ReadWriteLock中多次获取的ReadLock、WriteLock是同一把读锁，同一把写锁。

<4>.Lock锁和同步锁（synchronized）的区别与对比

对比：

1.概念：都是用于加锁和保证线程安全的手段，知识Lock提供锁对象，而synchronized是基于对象头来实现的加锁

2.语法：locak显示的加锁，释放锁；而synchronized是内建锁（JVM内部构建的锁），隐式的加锁和释放锁，lock使用上来说更加灵活

3.功能：lock提供了多种获取锁的方式（获取锁，非阻塞式的获取锁，可中断的获取锁，超时获取锁等），而synchronized只有一种方式：竞争锁（竞争失败，阻塞）

4.性能：同一个时间点，竞争锁的线程数量越多，synchronized性能下降的越快（竞争失败的线程，不停的再阻塞态与唤醒态之间切换，用户态与内核态之间的切换），使用lock效果好。

<5>死锁

先上代码：

package threadadvanced.lesson1;

class Pen {
	private String pen = "笔" ; 
	public String getPen() {
		return pen;
	}
}
class Book {
	private String book = "本" ; 
	public String getBook() {
		return book;
	}
}
public class DeadLock {
	private static Pen pen = new Pen() ; 
	private static Book book = new Book() ; 
	public static void main(String[] args) {
		new DeadLock().deadLock();
	}
	public void deadLock() {
		Thread thread1 = new Thread(new Runnable() { // 笔线程
			@Override
			public void run() {
				synchronized (pen) {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread()+" :我有笔，我就不给你");
					synchronized (book) {
						System.out.println(Thread.currentThread()+" :把你的本给我！");
					}
				}
			}
		},"Pen") ; 
		
		Thread thread2 = new Thread(new Runnable() { // 本子线程
			@Override
			public void run() {
				synchronized (book) {
					System.out.println(Thread.currentThread()+" :我有本子，我就不给你！");
					synchronized (pen) {
						System.out.println(Thread.currentThread()+" :把你的笔给我！");
					}
				}
				
			}
		},"Book") ; 
		thread1.start();
		thread2.start();
	}
}

出现死锁：

jconsole检查死锁：

1.死锁出现的原因：
至少两个线程，互相持有对方需要的资源没有释放，再次申请对方以及持有的资源

2.出现死锁的后果：
线程互相阻塞等待地方的资源，会一直处于阻塞等待的状态

3.如何检测死锁：
使用jdk工具：jconsole（查看线程）---->jstack

4.解决死锁的方法：
（1）资源一次性分配（破坏请求与保持条件）
（2）在满足一定条件的时候，主动释放资源
（3）资源的有序分配：系统为每一类资源赋予一个编号，每个线程按照编号递请求资源，释放则相反

7.多线程案例

<1>生产者消费者问题

示例：
面包店
10个生产者，每个每次生产3个
20个消费者，每个每次消费一个

进阶版需求
面包师傅每个最多生产30次，面包店每天生产10303=900个面包
消费者也不是一直消费。把900个面包消费完结束

隐藏信息：面包店每天生产面包的最大数量为900个

消费者把900个面包消费完结束
代码示例：

/**
 * 面包店
 * 10个生产者，每个每次生产3个
 * 20个消费者，每个每次消费一个
 *
 * 进阶版需求
 * 面包师傅每个最多生产30次，面包店每天生产10*30*3=900个面包
 * 消费者也不是一直消费。把900个面包消费完结束
 *
 * 隐藏信息：面包店每天生产面包的最大数量为900个
 *            消费者把900个面包消费完结束
 */


public class AdvancedBreadShop {
    //面包店库存数
    private static int COUNT;

    //面包店生产面包的总数,不会消费的
    private static int PRODUCE_NUMBER;


    public static class Consumer implements Runnable{
        private String name;


        public Consumer(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            try {
                while (true){
                    synchronized (AdvancedBreadShop.class){
                        if(PRODUCE_NUMBER==900&&COUNT==0){
                            System.out.println("今天面包已经卖完了");
                            break;
                        }else {
                            if(COUNT==0){
                                AdvancedBreadShop.class.wait();
                            }else {
                                System.out.printf("%s消费了一个面包\n",this.name);
                                COUNT--;
                                AdvancedBreadShop.class.notifyAll();
                                Thread.sleep(100);
                            }
                        }
                    }
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    private static class Producer implements Runnable{
        private String name;


        public Producer(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            try {
                //生产者生产30次，结束循环
                for(int i=0;i<=30;i++) {
                    synchronized (AdvancedBreadShop.class){
                        if(i==30){
                            System.out.println("今天面包生产完了");
                            break;
                        }else {
                            if(COUNT>97){
                                AdvancedBreadShop.class.wait();
                            }else {
                                COUNT=COUNT+3;
                                PRODUCE_NUMBER=PRODUCE_NUMBER+3;
                                System.out.printf("%s生产了三个面包\n",this.name);
                                AdvancedBreadShop.class.notifyAll();
                                Thread.sleep(100);
                            }
                        }
                    }
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) {
        Thread[] Consumers=new Thread[20];
        Thread[] Producers=new Thread[10];
        for (int i = 0; i <20 ; i++) {
            Consumers[i]=new Thread(new Consumer(String.valueOf(i)));
        }
        for (int i = 0; i <10 ; i++) {
            Producers[i]=new Thread(new Producer(String.valueOf(i)));
        }
        for (int i = 0; i <20 ; i++) {
            Consumers[i].start();
        }
        for (int i = 0; i <10 ; i++) {
            Producers[i].start();
        }
    }
}

<2>单例模式

1.饿汉式（线程安全）

public class Singleton {
    private static Singleton instance=new Singleton();//对象的创建是类加载的时候进行
    private Singleton() {}
    public static Singleton getInstance(){
        return instance;
    }
}

缺点：

<1>类加载时就创建了对象，但是在很多场景下，获取对象时，才需要实例化对象，这样才能节省内存空间，节省new对象的操作时间

<2>new对象操作，没有类加载，需要先执行类加载，在执行对象初始化的工作（成员变量，示例代码快，构造方法），如果执行时，这些抛异常了，那么以后都不能再使用

2.懒汉式（单线程版）

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

存在共享变量instanc，线程不安全

<3>懒汉式（多线程版，性能较低）

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

<4>

基于单例模式下的懒汉模式（双重校验锁实现）（多线程版，二次判断，效率高）
代码示例：

public class Singleton {
    //volatile关键字修饰，保证的可见性和代码的顺序性
    private static volatile Singleton instance = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        //判断instance是否为空，竞争锁的条件
        if (instance == null) {
            //保证线程安全，为Singleton.class加锁
            synchronized (Singleton.class) {
                //再次判断instance是否为空，防止多个线程进入第一个if后
                //对synchronized锁竞争失败进入阻塞状态后，再次进入运行态时
                //new了多个Singleton，不符合单例模式
                //保证线程安全
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
        }
        }

<3>阻塞式队列

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

阻塞式队列代码实现：

/**
 * 实现阻塞队列
 * 1.线程安全问题：在多线程情况下，put，take不具有原子性，4个属性，不具有可见性
 * 2.put操作：如果存满了，需要阻塞等待。take操作：如果是空，阻塞等待
 * @param 
 */
public class MyBlockingQueue <T>{
    //使用数组实现循环队列
    private Object[] queue;

    //存放元素的索引
    private int putIndex ;

    //取元素的索引
    private int takeIndex;

    //当前存放元素的数量
    private int size;
    public MyBlockingQueue(int len){
        queue=new Object[len];
    }

    //存放元素，需要考虑：
    //1.putIndex超过数组长度
    //2.size达到数组最大长度
    public synchronized void put(T e) throws InterruptedException {
        //不满足执行条件时，一直阻塞等待
        //当阻塞等待都被唤醒并再次竞争成功对象锁，回复往下执行时，条件可能被其他线程修改
        while (size==queue.length){
            this.wait();
        }
        //存放到数组中放元素的索引位置
        queue[putIndex]=e;
        putIndex=(putIndex+1)%queue.length;
        size++;
        notifyAll();
    }

    //取元素
    public synchronized T take() throws InterruptedException {
       while (size==0){
            this.wait();
        }
        T t= (T) queue[takeIndex];
        queue[takeIndex]=null;
        takeIndex=(takeIndex+1)%queue.length;
        size--;
        notifyAll();
        return t;
    }

    public int size(){
        return size;
    }

    public static void main(String[] args) {
        MyBlockingQueue<Integer>queue=new MyBlockingQueue<>(10);
        //多线程的调试方式：1.写打印语句 2.jconsole
        for (int i = 0; i <3 ; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        for (int j = 0; j <100 ; j++) {
                            queue.put(j);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        for (int i = 0; i <3 ; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                       while (true){
                          int t= queue.take();
                           System.out.println(Thread.currentThread().getName()+":"+t);
                       }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

<4>线程池

线程池最大的好处就是减少每次启动、销毁线程的损耗

import java.util.concurrent.*;

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //以快递公司，快递员，快递业务为模型
        ThreadPoolExecutor pool=new ThreadPoolExecutor(
                5,//核心线程数---->正式员工数
                10,//最大线程数-->正式员工+临时员工
                60,//临时工的最大等待时间(数量)
                TimeUnit.SECONDS,//idle线程的空闲时间(时间单位)-->临时工最大的存活时间，超过就解雇
                new LinkedBlockingQueue<>(),//阻塞队列，任务存放的地方--->快递仓库
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        return new Thread(new Runnable() {
                            @Override
                            public void run() {
                                //r对象是线程池内部封装过的工作任务类（Worker），会一直循环等待的方式从阻塞队列中拿取任务并执行
                                //所以不能调用r.run();方法
                                System.out.println(Thread.currentThread().getName()+"开始执行了");
                            }
                        });
                    }
                },//创建线程的工厂类  线程池创建线程时，调用该工厂类的方法创建线程（满足该工厂创建线程的要求）
                   //---->对应招聘员工的标准

                /**
                 * 拒绝策略：达到最大线程数且阻塞队列已满，采取拒绝策略
                 * AbortPolicy:直接抛出RejectedExecutionException(不提供handler时的默认策略）
                 * CallerRunsPolicy：谁（某个线程）交给我（线程池）的任务，我拒绝执行，由谁自己去执行
                 * DiscardPolicy：交给我的任务直接丢弃掉
                 * DiscardOldestPolicy：阻塞队列中最旧的任务丢弃
                 */
                new ThreadPoolExecutor.AbortPolicy()//拒绝策略-->达到最大线程数，且阻塞队列已满，采取的拒绝策略
        );//线程池创建以后，只要有任务们就会自动执行

        for (int i = 0; i <20 ; i++) {
            //线程池执行任务：execute方法，submit方法--->提交执行一个任务
            //区别：返回值不同
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        //线程池有4个快捷的创建方式（实际工作不使用，作为面试了解）
        //实际工作需要使用ThreadPoolExecutor，构造参数是我们自己指定，比较灵活
        ExecutorService pool2=Executors.newSingleThreadExecutor();//创建单线程池
        ExecutorService pool3=Executors.newCachedThreadPool();//缓存的线程池
        ExecutorService pool5=Executors.newFixedThreadPool(4);//固定大小线程池
        ScheduledExecutorService pool4=Executors.newScheduledThreadPool(4);//计划任务线程池

        //两秒中之后执行这个任务
        pool4.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        }, 2, TimeUnit.SECONDS);

        //一直执行任务
        pool4.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        }, 2, 1,TimeUnit.SECONDS);//比如一个脑子，两秒后开始叫我，然后每隔一秒叫我一次
    }
}

8.JUC包

共享锁：

<1>Semaphore(信号量 )

两个重要的API

  Semaphore semaphore=new Semaphore(0);
        semaphore.acquire();//需要/占用一个信号量
        semaphore.acquire(10);// 需要/占用10个型号量
        semaphore.release();//释放一个信号量
        semaphore.release(10);//释放是个信号量

两种使用场景：

1.当一定量线程执行完毕后，主线程才能执行

  public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(0);//初始时没有线程释放，这里设置为0
        for (int i = 0; i <10 ; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+"线程已经执行完毕，释放资源");
                semaphore.release();//释放一个信号量
            }).start();
        }
        try {
            semaphore.acquire(10);//需要信号量达到10，才执行
            System.out.println("main线程执行完毕");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

2.有限资源的争夺

十个线程抢五个有限资源

public class SemaphoreDemo2 {
    //有限资源的争夺  这里定义5个有限资源
    public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(5);//5个有限资源
        for (int i = 0; i < 10; i++) {//10个线程抢5个资源
            new Thread(()->{
                try {
                    semaphore.acquire();//占用一个资源
                    System.out.println(Thread.currentThread().getName()+"占用了一个资源");
                    Thread.sleep(1000);
                    semaphore.release();//释放了一个资源
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

<2>CountDownLatch

两个重要API

CountDownLatch countDownLatch=new CountDownLatch(10);//10个线程
countDownLatch.countDown();//latch初始为10，调用该方法减一
countDownLatch.await();//一直等待，latch减到0时释放

使用场景：

和上面信号量第一个一样，能用CountDownLatch解决的，信号量也可以

等待10个线程执行完毕，再执行主线程

public class CountDownLatchDemo {
    //案例：main线程在10个子线程执行完毕后才能执行
    public static void main(String[] args) {
        CountDownLatch countDownLatch=new CountDownLatch(10);//10个线程
        for (int i = 0; i <10 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"已经执行");
                countDownLatch.countDown();//Latch减一
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程执行完毕");
    }
}

<3>CyclicBarrier(循环栅栏)

CyclicBarrier cyclicBarrier=new CyclicBarrier(4);//初始化parties数
cyclicBarrier.await();//当await的线程小于4时，这些线程全部等待，达到4时，一起释放
cyclicBarrier.reset();// 将parties回归初始状态

示例：

public class CyclicBarrierDemo {
    //循环栅栏
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(4);
        for (int i = 0; i <10 ; i++) {
            new Thread(()->{
                try {
                    cyclicBarrier.await();
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"已经执行");
            }).start();
        }
    }
}

<4>ConcurrentHashMap

(1)ConcurrentHashMap加锁方式

结点结构：

 static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;
        }

1.底层的数据结构和HashMap jdk1.8版本一样，都是基于数组+链表+红黑树
2.支持多线程的并发操作，实现原理：CAS+Synchronized保证并发更新
3.put方法存储元素时，通过key的hashCode计算出相应数组的索引，如果没有Node，CAS自旋直到插入成功；如果存在Node，则使用synchronized 锁住该Node元素（链表或者红黑树）
4.键，值迭代器为弱一致性迭代器，创建迭代器之后，可以对元素进行更新
5.读操作没有加锁，value是volatile修饰的，保证了可见性，所以是安全的
6.读写分离可以提高效率：多线程多不同的Node/Segment的插入/删除操作是可以并发，并行的，多同一个Node/Segment的作用是互斥的。读操作都是无锁操作，可以并发，并行执行

7.1.7对一段加锁,使用ReentrantLock加锁，1.8使用CAS和Synchronized加锁

(2)fail-fast和fail-safe

HashMap的迭代器时fali-fast快速失败的迭代器（强一致性的），

ConcurrentHashMap等线程安全的数据结构，使用的都是fail-safe安全失败的迭代器（若一致性）

再fail-fast迭代器遍历的时候，如果发生了修改（插入，删除，修改），那么再次遍历下一个元素时，就会报错。

而fail-safe迭代器，当一个位置进行了修改（插入，删除，修改）操作时，另外一个位置也可以进行，不会报错.

9.ThreadLocal

<1>基础API

常用API：

案例：

public class ThreadLocalDemo {
    private String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public static void main(String[] args) {
        ThreadLocalDemo demo=new ThreadLocalDemo();
        for (int i = 0; i <10 ; i++) {
            Thread thread=new Thread(()->{
                demo.setContent(Thread.currentThread().getName()+"的数据");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"---->"+demo.getContent());
            });
            thread.setName("线程"+i);
            thread.start();
        }
    }
}

这里的content是这十个线程的共享变量，可能会出现以下结果：

而使用ThreadLocal时，就能实现content多个线程隔离

public class ThreadLocalDemo {
    private String content;

    ThreadLocal<String> threadLocal=new ThreadLocal<>();
    public String getContent() {
        return threadLocal.get();
    }

    public void setContent(String content) {
        threadLocal.set(content);
    }

    public static void main(String[] args) {
        ThreadLocalDemo demo=new ThreadLocalDemo();
        for (int i = 0; i <10 ; i++) {
            Thread thread=new Thread(()->{
                demo.setContent(Thread.currentThread().getName()+"的数据");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"---->"+demo.getContent());
            });
            thread.setName("线程"+i);
            thread.start();
        }
    }
}

<2>ThreadLocal和synchronized的区别

<3>ThreadLocal的内部结构

JDK早期的设计是ThreadLocal维护Thread，只有一个ThreadLocalMap，将Thread作为Map的key，存储的值作为Value

而JDK8的设计是：每个线程都有一个ThreadLocalMap，Thread维护，ThreadLocal对象本身作为Key，值作为Value存储

JDK8这样设计的好处：

1.早期的设计时，是ThreadLocal维护ThreadLocalMap，有多少个线程就有多少个Entry，较多

而JDK8这样设计，减少了Entry个数

2.当Thread销毁时，ThreadLocalMap也会随之销毁，减少了内存的使用

ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也是独立实现的

<4>ThrealLocal内存泄漏

弱引用造成内存泄漏：

如图：

1.弱引用原因: 假设ThreadLocal Ref用完被回收了，而ThreadLoca被弱引用Entry中的Key指向，也会被回收，此时Key就变为了null，但是如果没有手动删除Entry以及CurrentThread依然运行的前提下，也存在这强引用连threadLocal ->currentThread->threadLocalMap->Entry->value,而value不会被回收，但key的值为null，所以value永远都不会被访问到，导致内存泄漏

2.解决内存泄漏：

<1> 没有手动删除这个Entry：只要在使用完ThreadLocal，调用其remove方法删除对应的Entry，就能避免内存泄漏

<2>CurrentThread依然运行：由于ThreadLocalMap是Thread的一个属性，被当前线程所引用，所以它的生命周期和Thread一样长，那么在使用完ThreadLocal情况下，如果当前Thread也随之指向结束，那么ThreadLocalMap自然也会被GC所回收，从根源上避免了内存泄漏

**综上：**ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期和Thread一样长，如果没有手动删除对应的key就会导致内存泄漏

10.Java多线程相关面试题

<1>、volatile、ThreadLocal的使用场景和原理；

volatile原理

volatile变量进行写操作时，JVM 会向处理器发送一条 Lock 前缀的指令，将这个变量所在缓存行的数据写会到系统内存。

Lock 前缀指令实际上相当于一个内存屏障（也成内存栅栏），它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成。

volatile的适用场景

1）状态标志,如：初始化或请求停机

2）一次性安全发布，如：单列模式

3）独立观察，如：定期更新某个值

4）“volatile bean” 模式

开销较低的“读－写锁”策略，如：计数器

ThreadLocal原理

ThreadLocal是用来维护本线程的变量的，并不能解决共享变量的并发问题。ThreadLocal是各线程将值存入该线程的map中，以ThreadLocal自身作为key，需要用时获得的是该线程之前存入的值。如果存入的是共享变量，那取出的也是共享变量，并发问题还是存在的。

ThreadLocal的适用场景

场景：数据库连接、Session管理

<2>、ThreadLocal什么时候会出现OOM的情况？为什么？

ThreadLocal变量是维护在Thread内部的，这样的话只要我们的线程不退出，对象的引用就会一直存在。当线程退出时，Thread类会进行一些清理工作，其中就包含ThreadLocalMap， Thread调用exit方法如下：

ThreadLocal在没有线程池使用的情况下，正常情况下不会存在内存泄露，但是如果使用了线程池的话，就依赖于线程池的实现，如果线程池不销毁线程的话，那么就会存在内存泄露。

<3>、synchronized、volatile区别

volatile主要应用在多个线程对实例变量更改的场合，刷新主内存共享变量的值从而使得各个线程可以获得最新的值，线程读取变量的值需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。另外，synchronized还会创建一个内存屏障，内存屏障指令保证了所有CPU操作结果都会直接刷到主存中（即释放锁前），从而保证了操作的内存可见性，同时也使得先获得这个锁的线程的所有操作
volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。 volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞，比如多个线程争抢 synchronized锁对象时，会出现阻塞。
volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性，因为线程获得锁才能进入临界区，从而保证临界区中的所有语句全部得到执行。
volatile标记的变量不会被编译器优化，可以禁止进行指令重排；synchronized标记的变量可以被编译器优化。

8、synchronized锁粒度、模拟死锁场景；

synchronized：具有原子性，有序性和可见性

粒度：对象锁、类锁

<4>ThreadLocal的作用以及为什么发生内存泄漏和解决方法

作用：存放线程的本地变量，实现线程之间的隔离，它内部有静态内部类ThreadlocalMap，Entry，实现了和Map类似的功能，单没用实现Map接口，每个线程都有一个ThreadLocalMap的副本。Threadlocal继承了弱引用

内存泄漏：