Java多线程&并发知识总结

博主：皆非
发布时间：2021 年 09 月 07 日
1771 次浏览
暂无评论
33540字数
分类：知识总结

文章内容整理自JavaGuide

并发基础

进程与线程

进程：
- 系统分配资源的最小单位。
- 进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。
- （在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。）
线程：
- 系统调度资源的最小单位。
- 线程是一个比进程更小的执行单位。
- 一个进程在其执行的过程中可以产生多个线程。

与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

一个Java程序的运行是main线程和多个其他线程同时运行。

进程和线程的关系

线程进程关系图
从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的堆和方法区(JDK1.8之后的元空间)资源，但是每个线程有自己的程序计数器、虚拟机栈 和本地方法栈。

线程是进程划分成的更小的运行单位。
线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。
线程执行开销小，但不利于资源的管理和保护；而进程正相反。

程序计数器为什么私有

程序计数器主要有下面两个作用：

字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。

如果执行的是native方法，那么程序计数器记录的是undefined地址，只有执行的是Java代码时程序计数器记录的才是下一条指令的地址。

所以，程序计数器私有主要是为了线程切换后能恢复到正确的执行位置。

虚拟机栈和本地方法栈为什么私有

虚拟机栈：每个Java方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在Java虚拟机栈中入栈和出栈的过程。
本地方法栈：和虚拟机栈所发挥的作用非常相似，区别是：虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则为虚拟机使用到的Native方法服务。在HotSpot虚拟机中和Java虚拟机栈合二为一。

堆和方法区

堆和方法区是所有线程共享的资源
其中堆是进程中最大的一块内存，主要用于存放新创建的对象 (几乎所有对象都在这里分配内存)
方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

并行与并发

并发：同一时间段，多个任务都在执行 (单位时间内不一定同时执行)
并行：同一时刻，多个任务同时执行

多线程的优缺

优点：
- 线程间的切换和调度的成本远远小于进程。
- 多核cpu也减少了线程上下文切换的开销。
- 利用好多线程机制可以大大提高系统整体的并发能力以及性能
缺点：
- 并发编程并不总是能提高程序运行速度
- 可能会造成内存泄漏、死锁、线程不安全等等

Java线程的生命周期

Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态
Java线程的状态
线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换
Java线程切换
线程创建之后它将处于NEW（新建）状态，调用start()方法后开始运行，线程这时候处于READY（可运行）状态。可运行状态的线程获得了CPU 时间片（timeslice）后就处于RUNNING（运行）状态。

在操作系统中层面线程有READY和RUNNING状态，JVM将其统称为RUNNABLE（运行中）状态，因为线程切换太快

上下文切换

线程在执行过程中会有自己的运行条件和状态（也称上下文），比如上文所说到过的程序计数器，栈信息，CPU寄存器状态等。
当出现如下情况的时候，线程会从占用CPU状态中退出。

动让出 CPU，比如调用了sleep(), wait()等。
时间片用完
调用了阻塞类型的系统中断，比如请求IO，线程被阻塞。
被终止或结束运行

这其中前三种都会发生线程切换，线程切换意味着需要保存当前线程的上下文，留待线程下次占用 CPU 的时候恢复现场。并加载下一个将要占用CPU的线程上下文。这就是所谓的上下文切换。

上下文切换是现代操作系统的基本功能，因其每次需要保存信息恢复信息，这将会占用 CPU，内存等系统资源进行处理，也就意味着效率会有一定损耗，如果频繁切换就会造成整体效率低下。

死锁

产生的条件：

互斥条件：该资源任意一个时刻只由一个线程占用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件: 线程已获得的资源在未使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
循环等待条件: 若干进程之间形成一种头尾相接的循环等待资源关系。

预防死锁：

破坏请求与保持条件：一次性申请所有的资源。
破坏不剥夺条件：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
破坏循环等待条件：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。

避免死锁：

在资源分配时，借助于算法（比如银行家算法）对资源分配进行计算评估，使其进入安全状态。

安全状态指的是系统能够按照某种进行推进顺序（P1、P2、P3.....Pn）来为每个进程分配所需资源，直到满足每个进程对资源的最大需求，使每个进程都可顺利完成。称<P1、P2、P3.....Pn>序列为安全序列。

sleep()与wait()

两者最主要的区别在于：sleep() 方法没有释放锁，而 wait() 方法释放了锁 。
两者都可以暂停线程的执行。
wait()通常被用于线程间交互/通信，sleep()通常被用于暂停执行。
wait()方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的notify()或者notifyAll() 方法。
sleep()方法执行完成后，线程会自动苏醒。或者可以使用wait(long timeout)超时后线程会自动苏醒。

start()和run()

new 一个Thread，线程进入了新建状态
调用 start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了
start()会执行线程的相应准备工作，然后自动执行run()方法
直接执行 run() 方法，会把run()方法当成一个 main 线程下的普通方法去执行

调用start()方法方可启动线程并使线程进入就绪状态，直接执行run()方法的话不会以多线程的方式执行。

并发进阶

Thread

位于java.lang包下的Thread类是非常重要的线程类，它实现了Runnable接口

在Thread类中，有一些比较关键的属性，比如

name是表示Thread的名字，可以通过Thread类的构造器中的参数来指定线程名字
priority表示线程的优先级（最大值为10，最小值为1，默认值为5）
daemon表示线程是否是守护线程
target表示要执行的任务。

start()

start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。

run()

run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。

sleep()

sleep(long millis)    //参数为毫秒
sleep(long millis,int nanoseconds)   //第一参数为毫秒，第二个参数为纳秒

sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。
如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep()方法来实现。

当前线程调用sleep()方法进入阻塞状态后，在其睡眠时间内，该线程不会获得执行机会，即使系统中没有其他可执行线程，处于sleep()中的线程也不会执行，因此sleep()方法常用来暂停程序的执行

但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。

注意，如果调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态

yield()

yield()方法和sleep()方法有点相似，它也是Thread类提供的一个静态方法，它也可以让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入到就绪状态。即让当前线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况是：当某个线程调用了yield()方法暂停之后，线程调度器又将其调度出来重新执行。

join()

join()
join(long millis)    //参数为毫秒
join(long millis,int nanoseconds)   //第一参数为毫秒，第二个参数为纳秒

假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待一定的时间之后，再继续执行。如果调用的是无参join方法，则等待thread执行完毕，如果调用的是指定了时间参数的join方法，则等待一定的事件。

实际上调用join方法是调用了Object的wait方法，wait方法会让线程进入阻塞状态，并且会释放线程占有的锁，并交出CPU执行权限。

interrupt()

Thread.interrupt()并不会中断线程的运行，它的作用仅仅是为线程设定一个状态而已，即标明线程是中断状态

这样线程的调度机制或我们的代码逻辑就可以通过判断这个状态做一些处理，比如sleep()方法会抛出异常，或是我们根据isInterrupted()方法判断线程是否处于中断状态，然后做相关的逻辑处理

处于阻塞的线程，即在执行Object对象的wait()、wait(long)、wait(long, int)，或者线程类的join()、join(long)、join(long, int)、sleep(long)、sleep(long,int)方法后线程的状态，当线程调用interrupt()方法后，这些方法将抛出InterruptedException异常，并清空线程的中断状态，即isInterrupted()返回false

抛出异常是为了线程从阻塞状态醒过来，并在结束线程前让程序员有足够的时间来处理中断请求。

直接调用interrupt方法不能中断正在运行中的线程。(但是如果配合isInterrupted()能够中断正在运行的线程)

interrupted()

interrupted()函数是Thread静态方法，用来检测当前线程的interrupt状态，检测完成后，状态清空。

即，如果连续两次调用该方法，则第二次调用将返回 false。该方法可用于清除线程中断状态使用。

stop()

stop方法已经是一个废弃的方法，它是一个不安全的方法。因为调用stop方法会直接终止run方法的调用，并且会抛出一个ThreadDeath错误，如果线程持有某个对象锁的话，会完全释放锁，导致对象状态不一致。所以stop方法基本是不会被用到的。

destroy方法

destroy方法也是废弃的方法。基本不会被使用到。

其他

//用来得到线程ID
getId
//用来得到或者设置线程名称
getName和setName
//用来获取和设置线程优先级
getPriority和setPriority
//用来设置线程是否成为守护线程和判断线程是否是守护线程。
setDaemon
isDaemon

守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。

举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。

Thread类有一个比较常用的静态方法currentThread()用来获取当前线程。

中断补充

线程同步机制中，中断状态的使用：

如果一个线程处于了阻塞状态（如线程调用了thread.sleep、thread.join、thread.wait、1.5中的condition.await、以及可中断的通道上的 I/O 操作方法后可进入阻塞状态），则线程会一直检查中断状态标示

如果发现中断状态标示为true，则会在这些阻塞方法（sleep、join、wait、1.5中的condition.await及可中断的通道上的 I/O 操作方法）调用处抛出InterruptedException异常，并且在抛出异常后立即将线程的中断标示位清除，即重新设置为false。

抛出异常是为了线程从阻塞状态醒过来，并在结束线程前让程序员有足够的时间来处理中断请求。

synchronized在获锁的过程中是不能被中断的，意思是说如果产生了死锁，则不可能被中断。

与synchronized功能相似的reentrantLock.lock()方法也是一样，它也不可中断的，即如果发生死锁，那么reentrantLock.lock()方法无法终止，如果调用时被阻塞，则它一直阻塞到它获取到锁为止。

但是如果调用带超时的tryLock方法reentrantLock.tryLock(long timeout, TimeUnit unit)，那么如果线程在等待时被中断，将抛出一个InterruptedException异常，这是一个非常有用的特性，因为它允许程序打破死锁。

你也可以调用reentrantLock.lockInterruptibly()方法，它就相当于一个超时设为无限的tryLock方法。

synchronized

介绍

synchronized 关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

在 Java 早期版本中，synchronized 属于重量级锁，效率低下：

使用

修饰实例方法: 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁
修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例，进入同步代码前要获得当前 class 的锁。
修饰代码块：指定加锁对象，对给定对象/类加锁。synchronized(this|object) 表示进入同步代码库前要获得给定对象的锁。synchronized(类.class) 表示进入同步代码前要获得当前 class 的锁
```
synchronized(this) {
  //业务代码
}
```
总结：
synchronized 关键字加到 static 静态方法和 synchronized(class) 代码块上都是是给 Class 类上锁
synchronized 关键字加到实例方法上是给对象实例上锁。
尽量不要使用 synchronized(String a) 因为 JVM 中，字符串常量池具有缓存功能！
构造方法不能使用 synchronized 关键字修饰。

双重校验锁实现对象单例（线程安全）

public class Singleton {
    //volatile 禁止 JVM 的指令重排
    private volatile static Singleton uniqueInstance;
    private Singleton() {
    }
    public  static Singleton getUniqueInstance() {
       //先判断对象是否已经实例过，没有实例化过才进入加锁代码
        if (uniqueInstance == null) {
            //类对象加锁
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

JVM原理

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。
synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的确实是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法。

JDK1.6之后的优化

JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。
锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

与ReentrantLock 的区别

两者都是可重入锁

“可重入锁” 指的是自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增 1，所以要等到锁的计数器下降为 0 时才能释放锁。

可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

class MyClass {
    public synchronized void method1() {
        method2();
    }
    public synchronized void method2() {

    }
}

上述代码中的两个方法method1和method2都用synchronized修饰了。假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可重入性，此时线程A需要重新申请锁。但是，这就会造成死锁，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。而由于synchronized和Lock都具备可重入性，所以不会发生上述现象。

synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API
synchronized 是依赖于 JVM 实现的，前面我们也讲到了虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。

ReentrantLock的高级功能

等待可中断: ReentrantLock提供了一种能够中断等待锁的线程的机制，通过 lock.lockInterruptibly() 来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
可实现公平锁 : ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。ReentrantLock默认情况是非公平的，可以通过 ReentrantLock类的ReentrantLock(boolean fair)构造方法来制定是否是公平的。
可实现选择性通知（锁可以绑定多个条件）: synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制。ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition()方法。

Condition是 JDK1.5 之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。在使用notify()/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知” ，这个功能非常重要，而且是 Condition 接口默认提供的。而synchronized关键字就相当于整个 Lock 对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法只会唤醒注册在该Condition实例中的所有等待线程。

volatile

CPU 缓存模型

CPU Cache 缓存的是内存数据用于解决 CPU 处理速度和内存不匹配的问题，内存缓存的是硬盘数据用于解决硬盘访问速度过慢的问题。

CPU Cache 的工作方式：

先复制一份数据到 CPU Cache 中，当 CPU 需要用到的时候就可以直接从 CPU Cache 中读取数据，当运算完成后，再将运算得到的数据写回 Main Memory 中。但是，这样存在内存缓存不一致性的问题！比如我执行一个 i++操作的话，如果两个线程同时执行的话，假设两个线程从 CPU Cache 中读取的 i=1，两个线程做了 1++运算完之后再写回 Main Memory 之后 i=2，而正确结果应该是 i=3。

CPU 为了解决内存缓存不一致性问题可以通过制定缓存一致协议或者其他手段来解决。

JMM(Java 内存模型)

在 JDK1.2 之前，Java 的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以把变量保存本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。

要解决这个问题，就需要把变量声明为 volatile ，这就指示 JVM，这个变量是共享且不稳定的，每次使用它都到主存中进行读取。

所以，volatile 关键字除了防止 JVM 的指令重排，还有一个重要的作用就是保证变量的可见性。

并发编程的三个重要特性

原子性: 一个的操作或者多次操作，要么所有的操作全部都得到执行并且不会收到任何因素的干扰而中断，要么所有的操作都执行，要么都不执行。synchronized 可以保证代码片段的原子性。
可见性：当一个变量对共享变量进行了修改，那么另外的线程都是立即可以看到修改后的最新值。volatile 关键字可以保证共享变量的可见性。
有序性：代码在执行的过程中的先后顺序，Java 在编译器以及运行期间的优化，代码的执行顺序未必就是编写代码时候的顺序。volatile 关键字可以禁止指令进行重排序优化。

synchronized和volatile的区别

synchronized 关键字和 volatile 关键字是两个互补的存在，而不是对立的存在！

volatile 关键字是线程同步的轻量级实现，所以 volatile 性能肯定比synchronized关键字要好 。但是 volatile 关键字只能用于变量而 synchronized 关键字可以修饰方法以及代码块 。
volatile 关键字能保证数据的可见性，但不能保证数据的原子性。synchronized 关键字两者都能保证。
volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized 关键字解决的是多个线程之间访问资源的同步性。

Lock

locks包下常用的类与接口

java.util.concurrent.locks包下常用的类与接口（lock是jdk 1.5后新增的）

Lock

Lock和ReadWriteLock是两大锁的根接口，Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。

Lock 接口支持那些语义不同（重入、公平等）的锁规则，可以在非阻塞式结构的上下文（包括 hand-over-hand 和锁重排算法）中使用这些规则。主要的实现是 ReentrantLock。

ReadWriteLock

ReadWriteLock 接口以类似方式定义了一些读取者可以共享而写入者独占的锁。此包只提供了一个实现，即 ReentrantReadWriteLock，因为它适用于大部分的标准用法上下文。但程序员可以创建自己的、适用于非标准要求的实现。

Condition

Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。

synchronized的缺陷

synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？

Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。
Lock是一个类，通过这个类可以实现同步访问；
Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；
而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

Lock 的优点

如果一个代码块被synchronized关键字修饰，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待直至占有锁的线程释放锁。事实上，占有锁的线程释放锁一般会是以下三种情况之一：

占有锁的线程执行完了该代码块，然后释放对锁的占有；
占有锁线程执行发生异常，此时JVM会让线程自动释放锁；
占有锁线程进入 WAITING 状态从而释放锁，例如在该线程中调用wait()方法等。

试考虑以下三种情况：

情景1

在使用synchronized关键字的情形下，假如占有锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程就只能一直等待，别无他法。这会极大影响程序执行效率。

因此，就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间 (解决方案：tryLock(long time, TimeUnit unit)) 或者能够响应中断 (解决方案：lockInterruptibly())），这种情况可以通过 Lock 解决。

情景2

我们知道，当多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作也会发生冲突现象，但是读操作和读操作不会发生冲突现象。

但是如果采用synchronized关键字实现同步的话，就会导致一个问题，即当多个线程都只是进行读操作时，也只有一个线程在可以进行读操作，其他线程只能等待锁的释放而无法进行读操作。

因此，需要一种机制来使得当多个线程都只是进行读操作时，线程之间不会发生冲突。同样地，Lock也可以解决这种情况 (解决方案：ReentrantReadWriteLock) 。

情景3

我们可以通过Lock得知线程有没有成功获取到锁 (解决方案：ReentrantLock) ，但这个是synchronized无法办到的。

上面提到的三种情形，我们都可以通过Lock来解决，但 synchronized 关键字却无能为力。

事实上，Lock 是 java.util.concurrent.locks包下的接口，Lock 实现提供了比 synchronized 关键字更广泛的锁操作，它能以更优雅的方式处理线程同步问题。

也就是说，Lock提供了比synchronized更多的功能。

Lock接口实现类的使用

Lock接口有6个方法：

// 获取锁  
void lock()   
// 如果当前线程未被中断，则获取锁，可以响应中断  
void lockInterruptibly()   
// 返回绑定到此 Lock 实例的新 Condition 实例  
Condition newCondition()   
// 仅在调用时锁为空闲状态才获取该锁，可以响应中断  
boolean tryLock()   
// 如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁  
boolean tryLock(long time, TimeUnit unit)   
// 释放锁  
void unlock()

lock()、tryLock()、tryLock(long time, TimeUnit unit) 和 lockInterruptibly()都是用来获取锁的。

unLock()方法是用来释放锁的。

newCondition() 返回绑定到此 Lock 的新的 Condition 实例，用于线程间的协作

lock()

lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。在前面已经讲到，如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。

因此，一般来说，使用Lock必须在try…catch…块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

Lock lock = ...;
lock.lock();
try{
    //处理任务
}catch(Exception ex){

}finally{
    lock.unlock();   //释放锁
}

tryLock()

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

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false，同时可以响应中断。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){

     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}

lockInterruptibly()

lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够 响应中断，即中断线程的等待状态。

例如，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出 InterruptedException，但推荐使用后者，原因稍后阐述。因此，lockInterruptibly()一般的使用形式如下：

public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {  
     //.....
    }
    finally {
        lock.unlock();
    }  
}

注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。

因为interrupt()方法只能中断阻塞过程中的线程而不能中断正在运行过程中的线程。

因此，当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，那么只有进行等待的情况下，才可以响应中断的。

与 synchronized 相比，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

ReentrantLock

ReentrantLock，即可重入锁。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。下面通过一些实例学习如何使用 ReentrantLock。

构造方法（不带参数和带参数 true：公平锁； false: 非公平锁）：

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;
public class LockThread {
    Lock lock = new ReentrantLock(); 
    public void lock(String name) {  
        // 获取锁  
        lock.lock();  
        try {  
            System.out.println(name + " get the lock");  
            // 访问此锁保护的资源  
        } finally {  
            // 释放锁  
            lock.unlock();  
            System.out.println(name + " release the lock");  
        }  
    }  

    public static void main(String[] args) {
        LockThread lt = new LockThread();  
        new Thread(() -> lt.lock("A")).start();  
        new Thread(() -> lt.lock("B")).start();  
    }
}

从执行结果可以看出，A线程和B线程同时对资源加锁，A线程获取锁之后，B线程只好等待，直到A线程释放锁B线程才获得锁。

总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点：

synchronized是Java语言的关键字，因此是内置特性，Lock不是Java语言内置的，Lock是一个接口，通过实现类可以实现同步访问。
synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定
但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中
在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态。

ReadWriteLock

ReadWriteLock 接口只有两个方法：

//返回用于读取操作的锁  
Lock readLock()   
//返回用于写入操作的锁  
Lock writeLock()

ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。

只要没有 writer，读取锁可以由多个 reader 线程同时保持，而写入锁是独占的。

【例子】三个线程同时对一个共享数据进行读写

import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class Queue {
    //共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
    private Object data = null;
    ReadWriteLock lock = new ReentrantReadWriteLock();
    // 读数据
    public void get() {
        // 加读锁
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to read data!");
            Thread.sleep((long) (Math.random() * 1000));
            System.out.println(Thread.currentThread().getName() + " have read data :" + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放读锁
            lock.readLock().unlock();
        }
    }
    // 写数据
    public void put(Object data) {
        // 加写锁
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to write data!");
            Thread.sleep((long) (Math.random() * 1000));
            this.data = data;
            System.out.println(Thread.currentThread().getName() + " have write data: " + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放写锁
            lock.writeLock().unlock();
        }
    }
}
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        final Queue queue = new Queue();
        //一共启动6个线程，3个读线程，3个写线程
        for (int i = 0; i < 3; i++) {
            //启动1个读线程
            new Thread() {
                public void run() {
                    while (true) {
                        queue.get();
                    }
                }
            }.start();
            //启动1个写线程
            new Thread() {
                public void run() {
                    while (true) {
                        queue.put(new Random().nextInt(10000));
                    }
                }
            }.start();
        }
    }
}

ReentrantReadWriteLock

位于 java.util.concurrent.locks 包下，它实现了 ReadWriteLock 接口和 Serializable 接口
ReentrantReadWriteLock读写锁在ReentrantLock上进行了拓展
读写锁是“读写互斥，写写互斥，读读共享” 的锁
读锁和写锁共用同一个 原子state 和 On Sync Queue 来进行资源控制，它把对共享资源对访问者划分成了读者和写者，读者只对共享资源进行访问，写者则是对共享资源进行写操作
在没有写操作的时候，允许多个线程同时读取共享资源，同一个线程读可以重入（但是同一个线程不可以获取写锁）
如果一个线程想去写这些共享资源，不允许其他线程对该资源进行读和写的操作了（但是同一个线程读写可以重入）

特性

公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平
重进入：读锁和写锁都支持线程重入
锁降级：遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁
锁升级：读锁是不能直接升级为写入锁的。因为获取一个写入锁需要释放所有读取锁，所以如果有两个读取锁视图获取写入锁而都不释放读取锁时就会发生死锁

线程进入读锁的前提条件：

没有任何锁，那么读锁可以立马获取
有读锁，那么读锁可以立马获取
没有其他线程的写锁，那么读锁可以立马获取
有同一线程的写锁，获取读锁会产生锁降级（必须是先获得写锁再获取读锁，不然会造成死锁）

线程进入写锁的前提条件：

没有任何锁，那么可以立刻获的写锁
没有读锁，没其他线程的写锁，那么可以立刻获的写锁

Sync类的源码

Sync是ReentrantReadWriteLock内部实现的一个内部类，Sync继承了AbstractQueuedSynchronizer（AQS）
Sync将Aqs的state分为高16位，低16位
低16位表示写锁计数（可重入次数），写锁重入个数加1，其实是status状态值加 1
高16位表示持有读锁的线程数（多线程读），读锁个数加1，其实是status状态值加 2^16
写锁用高位部分（即EXCLUSIVE_MASK：65535）&status状态值来计算写锁的重入计数（实际上是将高位的二进制置为0）

ThreadLocal

简介

ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。

如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是ThreadLocal变量名的由来。他们可以使用 get（） 和 set（） 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。

原理

public class Thread implements Runnable {
    //......
    //与此线程有关的ThreadLocal值。由ThreadLocal类维护
    ThreadLocal.ThreadLocalMap threadLocals = null;

    //与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    //......
}

从上面Thread类源代码可以看出Thread 类中有一个 threadLocals 和一个 inheritableThreadLocals 变量，它们都是 ThreadLocalMap 类型的变量,我们可以把 ThreadLocalMap 理解为ThreadLocal 类实现的定制化的 HashMap。默认情况下这两个变量都是 null，只有当前线程调用 ThreadLocal 类的 set或get方法时才创建它们，实际上调用这两个方法的时候，我们调用的是ThreadLocalMap类对应的 get()、set()方法。

最终的变量是放在了当前线程的 ThreadLocalMap 中，并不是存在 ThreadLocal 上，ThreadLocal 可以理解为只是ThreadLocalMap的封装，传递了变量值。 ThrealLocal 类中可以通过Thread.currentThread()获取到当前线程对象后，直接通过getMap(Thread t)可以访问到该线程的ThreadLocalMap对象。

每个Thread中都具备一个ThreadLocalMap，而ThreadLocalMap可以存储以ThreadLocal为 key ，Object 对象为 value 的键值对。

比如我们在同一个线程中声明了两个 ThreadLocal 对象的话，会使用 Thread内部都是使用仅有那个ThreadLocalMap 存放数据的，ThreadLocalMap的 key 就是 ThreadLocal对象，value 就是 ThreadLocal 对象调用set方法设置的值。

内存泄露问题

ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用,而 value 是强引用。
所以，如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候，key 会被清理掉，而 value 不会被清理掉。这样一来，ThreadLocalMap 中就会出现 key 为 null 的 Entry。
假如我们不做任何措施的话，value 永远无法被 GC 回收，这个时候就可能会产生内存泄露。
ThreadLocalMap 实现中已经考虑了这种情况，在调用 set()、get()、remove() 方法的时候，会清理掉 key 为 null 的记录。使用完 ThreadLocal方法后最好手动调用remove()方法

线程池

优点

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

Executor 框架

Executor 框架是 Java5 之后引进的，在 Java 5 之后，通过 Executor 来启动线程比使用 Thread 的 start 方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题。

Executor 框架的构成：

任务(Runnable /Callable)

执行任务需要实现的 Runnable 接口或 Callable接口。

Runnable 接口或Callable 接口实现类都可以被 ThreadPoolExecutor 或 ScheduledThreadPoolExecutor 执行。

Runnable 接口不会返回结果或抛出检查异常，但是 Callable 接口可以。
所以，如果任务不需要返回结果或抛出异常推荐使用 Runnable 接口，这样代码看起来会更加简洁。

工具类 Executors 可以实现将 Runnable 对象转换成 Callable 对象。

任务的执行(Executor)

异步计算的结果(Future)

Future 接口以及 Future 接口的实现类 FutureTask 类都可以代表异步计算的结果。

execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；
submit()方法用于提交需要返回值的任务。线程池会返回一个 Future 类型的对象，通过这个 Future 对象可以判断任务是否执行成功，并且可以通过 Future 的 get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

Callable 接口的实现类提交给 ThreadPoolExecutor 或 ScheduledThreadPoolExecutor 执行,调用 submit() 方法时会返回一个 FutureTask 对象

主线程可以执行 FutureTask.get()方法来等待任务执行完成。

主线程也可以执行FutureTask.cancel（boolean mayInterruptIfRunning）来取消此任务的执行。

ThreadPoolExecutor

线程池实现类 ThreadPoolExecutor 是 Executor 框架最核心的类。

参数

ThreadPoolExecutor 3 个最重要的参数：

corePoolSize : 核心线程数线程数定义了最小可以同时运行的线程数量。
maximumPoolSize : 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。
workQueue: 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

ThreadPoolExecutor其他常见参数:

keepAliveTime:当线程池中的线程数量大于 corePoolSize 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 keepAliveTime才会被回收销毁；
unit : keepAliveTime 参数的时间单位。
threadFactory :executor 创建新线程的时候会用到。
handler :饱和（拒绝）策略。关于饱和策略下面单独介绍一下。

ThreadPoolExecutor 饱和策略定义:

ThreadPoolExecutor.AbortPolicy ：抛出 RejectedExecutionException来拒绝新任务的处理。（默认）
ThreadPoolExecutor.CallerRunsPolicy ：调用执行自己的线程运行任务，也就是直接在调用execute方法的线程中运行(run)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。
因此这种策略会降低对于新任务提交速度，影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话，你可以选择这个策略。（对于可伸缩的应用程序，建议使用）
ThreadPoolExecutor.DiscardPolicy ：不处理新任务，直接丢弃掉。
ThreadPoolExecutor.DiscardOldestPolicy ：此策略将丢弃最早的未处理的任务请求。

线程池的创建

推荐使用 ThreadPoolExecutor 构造函数创建线程池，不要使用Executors 去创建

示例代码

Runnable+ThreadPoolExecutor
MyRunnable.java

//这是一个简单的Runnable类，需要大约5秒钟来执行其任务。
public class MyRunnable implements Runnable {
    private String command;
    public MyRunnable(String s) {
        this.command = s;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
        processCommand();
        System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
    }
    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public String toString() {
        return this.command;
    }
}

ThreadPoolExecutorDemo.java

public class ThreadPoolExecutorDemo {
    //核心线程数为 5。
    private static final int CORE_POOL_SIZE = 5;
    //最大线程数 10
    private static final int MAX_POOL_SIZE = 10;
    //任务队列为 ArrayBlockingQueue，并且容量为 100;
    private static final int QUEUE_CAPACITY = 100;
    //等待时间为 1L。
    private static final Long KEEP_ALIVE_TIME = 1L;
    public static void main(String[] args) {
        //使用阿里巴巴推荐的创建线程池的方式
        //通过ThreadPoolExecutor构造函数自定义参数创建
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                ////饱和策略为 CallerRunsPolicy。
                new ThreadPoolExecutor.CallerRunsPolicy()); 

        for (int i = 0; i < 10; i++) {
            //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
            Runnable worker = new MyRunnable("" + i);
            //执行Runnable
            executor.execute(worker);
        }
        //终止线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}

比较

shutdown() VS shutdownNow()

shutdown（） :关闭线程池，线程池的状态变为 SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。
shutdownNow（） :关闭线程池，线程的状态变为 STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。

isTerminated() VS isShutdown()

isShutDown 当调用 shutdown() 方法后返回为 true。
isTerminated 当调用 shutdown() 方法后，并且所有提交的任务完成后返回为 true

ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor 主要用来在给定的延迟后运行任务，或者定期执行任务。
这个在实际项目中基本不会被用到，因为有其他方案选择比如quartz。

线程池大小确定

CPU 密集型任务(N+1)：这种任务消耗的主要是 CPU 资源，可以将线程数设置为 N（CPU 核心数）+1，比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。
一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。

I/O 密集型任务(2N)：这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。
因此在 I/O 密集型任务的应用中，我们可以多配置一些线程，具体的计算方法是 2N。

如何判断是 CPU 密集任务还是 IO 密集任务？
CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内存中对大量数据进行排序。
但凡涉及到网络读取，文件读取这类都是 IO 密集型，这类任务的特点是 CPU 计算耗费时间相比于等待 IO 操作完成的时间来说很少，大部分时间都花在了等待 IO 操作完成上。

Atomic

这里Atomic原子类是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

原子类说简单点就是具有原子/原子操作特征的类。

并发包 java.util.concurrent 的原子类都存放在java.util.concurrent.atomic下

JUC 包中的原子类

基本类型

使用原子的方式更新基本类型

AtomicInteger：整形原子类
AtomicLong：长整型原子类
AtomicBoolean：布尔型原子类

数组类型

使用原子的方式更新数组里的某个元素

AtomicIntegerArray：整形数组原子类
AtomicLongArray：长整形数组原子类
AtomicReferenceArray：引用类型数组原子类

引用类型

AtomicReference：引用类型原子类
AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
AtomicMarkableReference ：原子更新带有标记位的引用类型

对象的属性修改类型

AtomicIntegerFieldUpdater：原子更新整形字段的更新器
AtomicLongFieldUpdater：原子更新长整形字段的更新器
AtomicReferenceFieldUpdater：原子更新引用类型字段的更新器

AtomicInteger 的使用

public final int get() //获取当前的值
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
public final int getAndIncrement()//获取当前的值，并自增
public final int getAndDecrement() //获取当前的值，并自减
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

class AtomicIntegerTest {
    private AtomicInteger count = new AtomicInteger();
    //使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。
    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

AtomicInteger 类的原理

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

AQS

AQS 的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。

AQS 是一个用来构建锁和同步器的框架，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器

原理

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

CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点（Node）来实现锁的分配。

AQS 使用一个 int 成员变量来表示同步状态，通过内置的 FIFO 队列来完成获取资源线程的排队工作。AQS 使用 CAS 对该同步状态进行原子操作实现对其值的修改。

AQS 对资源的共享方式

AQS 定义两种资源共享方式

Exclusive（独占）：只有一个线程能执行，如 ReentrantLock。又可分为公平锁和非公平锁：

公平锁：按照线程在队列中的排队顺序，先到者先拿到锁
非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的

Share（共享）：多个线程可同时执行，如 CountDownLatch、Semaphore、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。

ReentrantReadWriteLock 可以看成是组合式，因为 ReentrantReadWriteLock 也就是读写锁允许多个线程同时对某一资源进行读。

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS 已经在顶层实现好了。

AQS 底层使用了模板方法模式

同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：

使用者继承 AbstractQueuedSynchronizer 并重写指定的方法。（这些重写方法很简单，无非是对于共享资源 state 的获取和释放）
将 AQS 组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。

AQS 组件总结

Semaphore(信号量)-允许多个线程同时访问： synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。
CountDownLatch（倒计时器）： CountDownLatch 是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。

CountDownLatch

CountDownLatch 的作用就是 允许 count 个线程阻塞在一个地方，直至所有线程的任务都执行完毕。

例如：要读取处理 6 个文件，这 6 个任务都是没有执行顺序依赖的任务，但是我们需要返回给用户的时候将这几个文件的处理的结果进行统计整理。

为此我们定义了一个线程池和 count 为 6 的CountDownLatch对象。使用线程池处理读取任务，每一个线程处理完之后就将 count-1，调用CountDownLatch对象的 await()方法，直到所有文件读取完之后，才会接着执行后面的逻辑。

最后修改：2021 年 11 月 23 日

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

小旭の破站
博客已添加你的网站啦！！！博客名称：小旭の破站博客地址：htt...
海风迂回
好滴，谢谢博主大大！！！希望有一天能成为你友链的一员
海风迂回
博主大大，我也想试试服务器自己搭的，想问问是看的什么文档呀
小旭の破站
博主还加友链嘛
海风迂回
博主大大，想搭一个这样的博客网站，请问有学习链接吗

Java多线程&并发知识总结

皆非 • 2021 年 09 月 07 日

<blockquote>
<p>文章内容整理自<span class="external-link"><a class="no-external-link" href="https://snailclimb.gitee.io/javaguide/#/?id=%E5%B9%B6%E5%8F%91" target="_blank"><i data-feather="external-link"></i>JavaGuide</a></span></p>
</blockquote>
<h1>并发基础</h1>
<h2>进程与线程</h2>
<ul>
<li><strong>进程</strong>：<ul>
<li>系统分配资源的最小单位。</li>
<li>进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。</li>
<li>（在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。）</li>
</ul>
</li>
<li><strong>线程</strong>：<ul>
<li>系统调度资源的最小单位。</li>
<li>线程是一个比进程更小的执行单位。</li>
<li>一个进程在其执行的过程中可以产生多个线程。</li>
</ul>
</li>
</ul>
<p><div class="tip inlineBlock success">

与进程不同的是同类的多个线程<strong>共享进程的堆和方法区资源</strong>，但每个线程有自己的<strong>程序计数器</strong>、<strong>虚拟机栈</strong>和<strong>本地方法栈</strong>，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为<strong>轻量级进程</strong>。
</div><br />
<div class="tip inlineBlock success">

一个Java程序的运行是main线程和多个其他线程同时运行。
</div></p>
<h2>进程和线程的关系</h2>
<p><img src="https://file.makeyourchoice.cn/2021/09/07/1630977097.jpg" alt="线程进程关系图" style=""><br />
从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的<strong>堆</strong>和<strong>方法区</strong>(JDK1.8之后的<strong>元空间</strong>)资源，但是每个线程有自己的<strong>程序计数器</strong>、<strong>虚拟机栈</strong> 和<strong>本地方法栈</strong>。<br />
<div class="tip inlineBlock success">

线程是进程划分成的更小的运行单位。<br />
线程和进程最大的不同在于基本上<strong>各进程是独立的</strong>，而各线程则不一定，因为<strong>同一进程中的线程极有可能会相互影响</strong>。<br />
线程执行开销小，但<strong>不利于资源的管理和保护</strong>；而进程正相反。
</div></p>
<h3>程序计数器为什么私有</h3>
<p>程序计数器主要有下面两个作用：</p>
<ul>
<li><strong>字节码解释器</strong>通过改变程序计数器来依次<strong>读取指令</strong>，从而实现代码的<strong>流程控制</strong>，如：顺序执行、选择、循环、异常处理。</li>
<li>在多线程的情况下，程序计数器用于<strong>记录当前线程执行的位置</strong>，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。<br />
<div class="tip inlineBlock info">

如果执行的是<strong>native</strong>方法，那么程序计数器记录的是<strong>undefined</strong>地址，只有执行的是Java代码时程序计数器记录的才是下一条指令的地址。
</div><br />
<div class="tip inlineBlock success">

所以，程序计数器私有主要是为了<strong>线程切换后能恢复到正确的执行位置</strong>。
</div></li>
</ul>
<h3>虚拟机栈和本地方法栈为什么私有</h3>
<ul>
<li><strong>虚拟机栈</strong>： 每个Java方法在执行的同时会创建一个<strong>栈帧</strong>用于存储<strong>局部变量表</strong>、<strong>操作数栈</strong>、<strong>常量池引用</strong>等信息。<strong>从方法调用直至执行完成的过程，就对应着一个栈帧在Java虚拟机栈中入栈和出栈的过程</strong>。</li>
<li><strong>本地方法栈</strong>： 和虚拟机栈所发挥的作用非常相似，区别是： 虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则为虚拟机使用到的<strong>Native</strong>方法服务。 在HotSpot虚拟机中和Java虚拟机栈合二为一。</li>
</ul>
<h3>堆和方法区</h3>
<ul>
<li>堆和方法区是所有线程共享的资源</li>
<li>其中堆是进程中最大的一块<strong>内存</strong>，主要用于存放<strong>新创建的对象</strong> (几乎所有对象都在这里分配内存)</li>
<li>方法区主要用于存放<strong>已被加载</strong>的<strong>类信息</strong>、<strong>常量</strong>、<strong>静态变量</strong>、即时编译器编译后的代码等数据。</li>
</ul>
<h2>并行与并发</h2>
<ul>
<li><strong>并发</strong>： 同一时间段，多个任务都在执行 (单位时间内不一定同时执行)</li>
<li><strong>并行</strong>： 同一时刻，多个任务同时执行</li>
</ul>
<h2>多线程的优缺</h2>
<ul>
<li>优点：<ul>
<li>线程间的切换和调度的成本远远小于进程。</li>
<li>多核cpu也减少了线程上下文切换的开销。</li>
<li>利用好多线程机制可以大大提高系统整体的并发能力以及性能</li>
</ul>
</li>
<li>缺点： <ul>
<li>并发编程并不总是能提高程序运行速度</li>
<li>可能会造成内存泄漏、死锁、线程不安全等等</li>
</ul>
</li>
</ul>
<h2>Java线程的生命周期</h2>
<p>Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态<br />
<img src="https://file.makeyourchoice.cn/2021/09/07/1630979769.png" alt="Java线程的状态" style=""><br />
线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换<br />
<img src="https://file.makeyourchoice.cn/2021/09/07/1630979930.jpg" alt="Java线程切换" style=""><br />
线程创建之后它将处于<strong>NEW（新建）</strong>状态，调用<strong>start()</strong>方法后开始运行，线程这时候处于<strong>READY（可运行）</strong>状态。可运行状态的线程获得了<strong>CPU 时间片（timeslice）</strong>后就处于<strong>RUNNING（运行）</strong>状态。<br />
<div class="tip inlineBlock info">

在操作系统中层面线程有<strong>READY</strong>和<strong>RUNNING</strong>状态，JVM将其统称为<strong>RUNNABLE（运行中）</strong>状态，因为线程切换太快
</div><br />
<img src="https://file.makeyourchoice.cn/2021/09/07/1630980323.png" alt="RUNNABLE-VS-RUNNING" style=""></p>
<p><img src="https://file.makeyourchoice.cn/2021/11/22/1637583086.jpg" alt="" style=""></p>
<h2>上下文切换</h2>
<p>线程在执行过程中会有自己的<strong>运行条件</strong>和<strong>状态</strong>（也称上下文），比如上文所说到过的<strong>程序计数器</strong>，<strong>栈信息</strong>，CPU寄存器状态等。<br />
当出现如下情况的时候，线程会从占用CPU状态中退出。</p>
<ul>
<li>动让出 CPU，比如调用了<strong>sleep(), wait()</strong>等。</li>
<li>时间片用完</li>
<li>调用了<strong>阻塞类型的系统中断</strong>，比如<strong>请求IO</strong>，线程被阻塞。</li>
<li>被终止或结束运行<br />
<div class="tip inlineBlock success">

这其中前三种都会发生线程切换，<strong>线程切换意味着需要保存当前线程的上下文</strong>，留待线程下次占用 CPU 的时候恢复现场。并加载下一个将要占用CPU的线程上下文。这就是所谓的上下文切换。
</div><br />
<div class="tip inlineBlock success">

上下文切换是现代操作系统的基本功能，因其每次需要保存信息恢复信息，这将会占用 CPU，内存等系统资源进行处理，也就意味着效率会有一定损耗，如果频繁切换就会造成整体效率低下。
</div></li>
</ul>
<h2>死锁</h2>
<p>产生的条件：</p>
<ul>
<li><strong>互斥条件</strong>：该资源任意一个时刻只由一个线程占用。</li>
<li><strong>请求与保持条件</strong>：一个进程因请求资源而阻塞时，对已获得的资源保持不放。</li>
<li><strong>不剥夺条件</strong>: 线程已获得的资源在未使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。</li>
<li><strong>循环等待条件</strong>: 若干进程之间形成一种头尾相接的循环等待资源关系。</li>
</ul>
<p>预防死锁：</p>
<ul>
<li>破坏请求与保持条件：一次性申请所有的资源。</li>
<li>破坏不剥夺条件 ：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。</li>
<li>破坏循环等待条件 ：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。</li>
</ul>
<p>避免死锁：</p>
<ul>
<li>在资源分配时，借助于算法（比如银行家算法）对资源分配进行计算评估，使其进入安全状态。<br />
<div class="tip inlineBlock info">

安全状态指的是系统能够按照某种进行推进顺序（P1、P2、P3.....Pn）来为每个进程分配所需资源，直到满足每个进程对资源的最大需求，使每个进程都可顺利完成。称&lt;P1、P2、P3.....Pn&gt;序列为安全序列。
</div></li>
</ul>
<h2>sleep()与wait()</h2>
<ul>
<li>两者最主要的区别在于：<strong>sleep() 方法没有释放锁，而 wait() 方法释放了锁</strong> 。</li>
<li>两者都可以暂停线程的执行。</li>
<li>wait()通常被用于线程间<strong>交互/通信</strong>，sleep()通常被用于<strong>暂停执行</strong>。</li>
<li>wait()方法被调用后，线程<strong>不会自动苏醒</strong>，需要别的线程调用<strong>同一个对象</strong>上的<strong>notify()</strong>或者<strong>notifyAll()</strong> 方法。</li>
<li>sleep()方法执行完成后，线程会自动苏醒。或者可以使用wait(long timeout)超时后线程会自动苏醒。</li>
</ul>
<h2>start()和run()</h2>
<ul>
<li>new 一个Thread，线程进入了新建状态</li>
<li>调用 start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了</li>
<li>start()会执行线程的相应<strong>准备工作</strong>，然后<strong>自动执行run()方法</strong></li>
<li>直接执行 run() 方法，会把run()方法当成一个 main 线程下的普通方法去执行<br />
<div class="tip inlineBlock success">

调用start()方法方可启动线程并使线程进入就绪状态，直接执行run()方法的话不会以多线程的方式执行。
</div></li>
</ul>
<h1>并发进阶</h1>
<h2>Thread</h2>
<p>位于java.lang包下的Thread类是非常重要的线程类，它实现了Runnable接口<br />
<img src="https://file.makeyourchoice.cn/2021/11/22/1637583965.jpg" alt="" style=""><br />
在Thread类中，有一些比较关键的属性，比如</p>
<ul>
<li>name是表示Thread的名字，可以通过Thread类的构造器中的参数来指定线程名字</li>
<li>priority表示线程的优先级（最大值为10，最小值为1，默认值为5）</li>
<li>daemon表示线程是否是守护线程</li>
<li>target表示要执行的任务。</li>
</ul>
<h3>start()</h3>
<p>start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。</p>
<h3>run()</h3>
<p>run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。</p>
<h3>sleep()</h3>
<pre><code class="language-java">sleep(long millis)    //参数为毫秒
sleep(long millis,int nanoseconds)   //第一参数为毫秒，第二个参数为纳秒</code></pre>
<p>sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。<br />
如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep()方法来实现。</p>
<p>当前线程调用sleep()方法进入阻塞状态后，在其睡眠时间内，该线程不会获得执行机会，即使系统中没有其他可执行线程，处于sleep()中的线程也不会执行，因此<strong>sleep()方法常用来暂停程序的执行</strong></p>
<p>但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。</p>
<p>注意，如果调用了sleep方法，必须捕获<code>InterruptedException</code>异常或者将该异常向上层抛出。当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态</p>
<h3>yield()</h3>
<p>yield()方法和sleep()方法有点相似，它也是Thread类提供的一个静态方法，它也可以让当前正在执行的线程暂停，但它<strong>不会阻塞该线程</strong>，它只是<strong>将该线程转入到就绪状态</strong>。即让当前线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况是：当某个线程调用了yield()方法暂停之后，线程调度器又将其调度出来重新执行。</p>
<h3>join()</h3>
<pre><code class="language-java">join()
join(long millis)    //参数为毫秒
join(long millis,int nanoseconds)   //第一参数为毫秒，第二个参数为纳秒</code></pre>
<p>假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待一定的时间之后，再继续执行。如果调用的是无参join方法，则等待thread执行完毕，如果调用的是指定了时间参数的join方法，则等待一定的事件。</p>
<p>实际上调用join方法是调用了Object的wait方法，wait方法会让线程进入阻塞状态，并且会释放线程占有的锁，并交出CPU执行权限。</p>
<h3>interrupt()</h3>
<p>Thread.interrupt()并不会中断线程的运行，它的作用仅仅是为线程设定一个状态而已，即标明线程是中断状态</p>
<p>这样线程的调度机制或我们的代码逻辑就可以通过判断这个状态做一些处理，比如sleep()方法会抛出异常，或是我们根据isInterrupted()方法判断线程是否处于中断状态，然后做相关的逻辑处理</p>
<p>处于阻塞的线程，即在执行Object对象的wait()、wait(long)、wait(long, int)，或者线程类的join()、join(long)、join(long, int)、sleep(long)、sleep(long,int)方法后线程的状态，当线程调用interrupt()方法后，这些方法将抛出InterruptedException异常，并清空线程的中断状态，即isInterrupted()返回false</p>
<p>抛出异常是为了线程从阻塞状态醒过来，并在结束线程前让程序员有足够的时间来处理中断请求。</p>
<p><strong>直接调用interrupt方法不能中断正在运行中的线程</strong>。(但是如果配合isInterrupted()能够中断正在运行的线程)</p>
<h3>interrupted()</h3>
<p>interrupted()函数是Thread静态方法，用来<strong>检测当前线程的interrupt状态</strong>，检测完成后，状态清空。</p>
<p>即，如果连续两次调用该方法，则第二次调用将返回 false。该方法可用于清除线程中断状态使用。</p>
<h3>stop()</h3>
<p>stop方法已经是一个废弃的方法，它是一个不安全的方法。因为调用stop方法会直接终止run方法的调用，并且会抛出一个ThreadDeath错误，如果线程持有某个对象锁的话，会完全释放锁，导致对象状态不一致。所以stop方法基本是不会被用到的。</p>
<h3>destroy方法</h3>
<p>destroy方法也是废弃的方法。基本不会被使用到。</p>
<h3>其他</h3>
<pre><code class="language-java">//用来得到线程ID
getId
//用来得到或者设置线程名称
getName和setName
//用来获取和设置线程优先级
getPriority和setPriority
//用来设置线程是否成为守护线程和判断线程是否是守护线程。
setDaemon
isDaemon</code></pre>
<p>守护线程和用户线程的区别在于：<strong>守护线程依赖于创建它的线程，而用户线程则不依赖</strong>。</p>
<p>举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像<strong>垃圾收集器线程</strong>就是守护线程。</p>
<p>Thread类有一个比较常用的静态方法<code>currentThread()</code>用来获取当前线程。</p>
<h3>中断补充</h3>
<p>线程同步机制中，中断状态的使用：</p>
<p>如果一个线程处于了阻塞状态（如线程调用了thread.sleep、thread.join、thread.wait、1.5中的condition.await、以及可中断的通道上的 I/O 操作方法后可进入阻塞状态），则线程会一直检查中断状态标示</p>
<p>如果发现中断状态标示为true，则会在这些阻塞方法（sleep、join、wait、1.5中的condition.await及可中断的通道上的 I/O 操作方法）调用处抛出InterruptedException异常，并且在抛出异常后立即将线程的中断标示位清除，即重新设置为false。</p>
<p>抛出异常是为了线程从阻塞状态醒过来，并在结束线程前让程序员有足够的时间来处理中断请求。</p>
<p>synchronized在获锁的过程中是不能被中断的，意思是说如果产生了死锁，则不可能被中断。</p>
<p>与synchronized功能相似的reentrantLock.lock()方法也是一样，它也不可中断的，即如果发生死锁，那么reentrantLock.lock()方法无法终止，如果调用时被阻塞，则它一直阻塞到它获取到锁为止。</p>
<p>但是如果调用带超时的tryLock方法reentrantLock.tryLock(long timeout, TimeUnit unit)，那么如果线程在等待时被中断，将抛出一个InterruptedException异常，这是一个非常有用的特性，因为它允许程序打破死锁。</p>
<p>你也可以调用reentrantLock.lockInterruptibly()方法，它就相当于一个超时设为无限的tryLock方法。</p>
<h2>synchronized</h2>
<p><img src="https://file.makeyourchoice.cn/2021/09/15/1631674474.png" alt="" style=""></p>
<h3>介绍</h3>
<p>synchronized 关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。</p>
<p>在 Java 早期版本中，synchronized 属于 重量级锁，效率低下：<br />
<div class="tip inlineBlock share">

因为<strong>监视器锁</strong>（monitor）是依赖于底层的操作系统的 <strong>Mutex Lock</strong>来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从<strong>用户态转换到内核态</strong>，这个状态之间的转换需要相对比较长的时间，时间成本相对较高。
</div></p>
<h3>使用</h3>
<ul>
<li>
<p><strong>修饰实例方法</strong>: 作用于当前<strong>对象实例加锁</strong>，进入同步代码前要获得 当前对象实例的锁</p>
</li>
<li>
<p><strong>修饰静态方法</strong>: 也就是给当前<strong>类加锁</strong>，会作用于类的<strong>所有对象实例</strong>，进入同步代码前要获得 当前 class 的锁。</p>
</li>
<li>
<p><strong>修饰代码块</strong>：指定加锁对象，对给定对象/类加锁。synchronized(this|object) 表示进入同步代码库前要获得给定对象的锁。synchronized(类.class) 表示进入同步代码前要获得 当前 class 的锁</p>
<pre><code class="language-java">synchronized(this) {
  //业务代码
}</code></pre>
<p>总结：</p>
</li>
<li>
<p>synchronized 关键字加到 static 静态方法和 synchronized(class) 代码块上都是是给 Class 类上锁</p>
</li>
<li>
<p>synchronized 关键字加到实例方法上是给对象实例上锁。</p>
</li>
<li>
<p>尽量不要使用 synchronized(String a) 因为 JVM 中，字符串常量池具有缓存功能！</p>
</li>
<li>
<p>构造方法不能使用 synchronized 关键字修饰。</p>
</li>
</ul>
<p><strong>双重校验锁实现对象单例（线程安全）</strong></p>
<pre><code class="language-java">public class Singleton {
    //volatile 禁止 JVM 的指令重排
    private volatile static Singleton uniqueInstance;
    private Singleton() {
    }
    public  static Singleton getUniqueInstance() {
       //先判断对象是否已经实例过，没有实例化过才进入加锁代码
        if (uniqueInstance == null) {
            //类对象加锁
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}</code></pre>
<h3>JVM原理</h3>
<ul>
<li><strong>synchronized 同步语句块</strong>的实现使用的是 <code>monitorenter</code> 和 <code>monitorexit</code> 指令，其中 <code>monitorenter</code> 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。</li>
<li><strong>synchronized 修饰的方法</strong>并没有 <code>monitorenter</code> 指令和 <code>monitorexit</code> 指令，取得代之的确实是 <code>ACC_SYNCHRONIZED</code> 标识，该标识指明了该方法是一个同步方法。</li>
</ul>
<h3>JDK1.6之后的优化</h3>
<ul>
<li>JDK1.6 对锁的实现引入了大量的优化，如<strong>偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化</strong>等技术来减少锁操作的开销。</li>
<li>锁主要存在四种状态，依次是：<strong>无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态</strong>，他们会随着竞争的激烈而逐渐升级。注意<strong>锁可以升级不可降级</strong>，这种策略是为了提高获得锁和释放锁的效率。</li>
</ul>
<h3>与ReentrantLock 的区别</h3>
<ul>
<li>两者都是<strong>可重入锁</strong><br />
<div class="tip inlineBlock success">

“可重入锁” 指的是自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增 1，所以要等到锁的计数器下降为 0 时才能释放锁。
</div></li>
</ul>
<p>可重入性在我看来实际上表明了 锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。</p>
<pre><code class="language-java">class MyClass {
    public synchronized void method1() {
        method2();
    }
    public synchronized void method2() {

}
}</code></pre>
<p>上述代码中的两个方法method1和method2都用synchronized修饰了。假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可重入性，此时线程A需要重新申请锁。但是，这就会造成死锁，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。而由于synchronized和Lock都具备可重入性，所以不会发生上述现象。</p>
<ul>
<li>synchronized 依赖于 <strong>JVM</strong> 而 ReentrantLock 依赖于 <strong>API</strong><br />
synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。</li>
</ul>
<h4>ReentrantLock的高级功能</h4>
<ul>
<li><strong>等待可中断</strong>: ReentrantLock提供了一种能够中断等待锁的线程的机制，通过 lock.lockInterruptibly() 来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。</li>
<li><strong>可实现公平锁</strong> : ReentrantLock可以指定是公平锁还是非公平锁。而<strong>synchronized只能是非公平锁</strong>。所谓的公平锁就是先等待的线程先获得锁。<strong>ReentrantLock默认情况是非公平的</strong>，可以通过 ReentrantLock类的ReentrantLock(boolean fair)构造方法来制定是否是公平的。</li>
<li><strong>可实现选择性通知（锁可以绑定多个条件）</strong>: synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制。ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition()方法。</li>
</ul>
<p><div class="tip inlineBlock share">

<code>Condition</code>是 JDK1.5 之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个<code>Lock</code>对象中可以创建多个<code>Condition</code>实例（即对象监视器），<strong>线程对象可以注册在指定的<code>Condition</code>中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 在使用<code>notify()/notifyAll()</code>方法进行通知时，被通知的线程是由 JVM 选择的，用<code>ReentrantLock</code>类结合<code>Condition</code>实例可以实现“选择性通知” </strong>，这个功能非常重要，而且是 <code>Condition</code> 接口默认提供的。而<code>synchronized</code>关键字就相当于整个 <code>Lock</code> 对象中只有一个<code>Condition</code>实例，所有的线程都注册在它一个身上。如果执行<code>notifyAll()</code>方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而<code>Condition</code>实例的<code>signalAll()</code>方法 只会唤醒注册在该<code>Condition</code>实例中的所有等待线程。
</div></p>
<h2>volatile</h2>
<h3>CPU 缓存模型</h3>
<p><strong>CPU Cache 缓存的是内存数据用于解决 CPU 处理速度和内存不匹配的问题，内存缓存的是硬盘数据用于解决硬盘访问速度过慢的问题。</strong><br />
<img src="https://file.makeyourchoice.cn/2021/09/15/1631693512.jpg" alt="" style=""></p>
<p>CPU Cache 的工作方式：</p>
<p>先复制一份数据到 CPU Cache 中，当 CPU 需要用到的时候就可以直接从 CPU Cache 中读取数据，当运算完成后，再将运算得到的数据写回 Main Memory 中。但是，这样存在 内存缓存不一致性的问题 ！比如我执行一个 i++操作的话，如果两个线程同时执行的话，假设两个线程从 CPU Cache 中读取的 i=1，两个线程做了 1++运算完之后再写回 Main Memory 之后 i=2，而正确结果应该是 i=3。</p>
<p>CPU 为了解决内存缓存不一致性问题可以通过制定缓存一致协议或者其他手段来解决。</p>
<h3>JMM(Java 内存模型)</h3>
<p>在 JDK1.2 之前，Java 的内存模型实现总是从<strong>主存</strong>（即<strong>共享内存</strong>）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以把变量保存本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。<br />
<img src="https://file.makeyourchoice.cn/2021/09/15/1631693618.jpg" alt="" style=""></p>
<p>要解决这个问题，就需要把变量声明为 <code>volatile</code> ，这就<strong>指示 JVM，这个变量是共享且不稳定的，每次使用它都到主存中进行读取。</strong></p>
<p>所以，<strong>volatile 关键字 除了防止 JVM 的指令重排 ，还有一个重要的作用就是保证变量的可见性。</strong></p>
<p><img src="https://file.makeyourchoice.cn/2021/09/15/1631693693.jpg" alt="" style=""></p>
<h3>并发编程的三个重要特性</h3>
<ul>
<li><strong>原子性</strong>: 一个的操作或者多次操作，要么所有的操作全部都得到执行并且不会收到任何因素的干扰而中断，要么所有的操作都执行，要么都不执行。<strong>synchronized 可以保证代码片段的原子性。</strong></li>
<li><strong>可见性</strong>：当一个变量对共享变量进行了修改，那么另外的线程都是立即可以看到修改后的最新值。<strong>volatile 关键字可以保证共享变量的可见性。</strong></li>
<li><strong>有序性</strong>：代码在执行的过程中的先后顺序，Java 在编译器以及运行期间的优化，代码的执行顺序未必就是编写代码时候的顺序。<strong>volatile 关键字可以禁止指令进行重排序优化。</strong></li>
</ul>
<h3>synchronized和volatile的区别</h3>
<p><code>synchronized</code> 关键字和 <code>volatile</code> 关键字是两个互补的存在，而不是对立的存在！</p>
<ul>
<li><code>volatile</code> 关键字是线程同步的<strong>轻量级实现</strong>，所以 <strong>volatile 性能肯定比synchronized关键字要好</strong> 。但是 <strong>volatile 关键字只能用于变量而 synchronized 关键字可以修饰方法以及代码块</strong> 。</li>
<li><code>volatile</code> 关键字能保证<strong>数据的可见性</strong>，但不能保证数据的原子性。<code>synchronized</code> 关键字<strong>两者都能保证</strong>。</li>
<li>volatile关键字主要用于解决变量在多个线程之间的<strong>可见性</strong>，而 synchronized 关键字解决的是多个线程之间访问资源的<strong>同步性</strong>。</li>
</ul>
<h2>Lock</h2>
<h3>locks包下常用的类与接口</h3>
<p><img src="https://file.makeyourchoice.cn/2021/10/28/1635391308.png" alt="java.util.concurrent.locks包下常用的类与接口（lock是jdk 1.5后新增的）" style=""></p>
<h4>Lock</h4>
<p><code>Lock</code>和<code>ReadWriteLock</code>是两大锁的根接口，Lock代表实现类是<code>ReentrantLock</code>（<strong>可重入锁</strong>），ReadWriteLock（读写锁）的代表实现类是<code>ReentrantReadWriteLock</code>。</p>
<p>Lock 接口支持那些语义不同（重入、公平等）的锁规则，可以在非阻塞式结构的上下文（包括 hand-over-hand 和锁重排算法）中使用这些规则。主要的实现是 <code>ReentrantLock</code>。</p>
<h4>ReadWriteLock</h4>
<p>ReadWriteLock 接口以类似方式定义了一些<strong>读取者可以共享而写入者独占的锁</strong>。此包只提供了一个实现，即 <code>ReentrantReadWriteLock</code>，因为它适用于大部分的标准用法上下文。但程序员可以创建自己的、适用于非标准要求的实现。</p>
<h4>Condition</h4>
<p>Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。</p>
<h3>synchronized的缺陷</h3>
<p><strong>synchronized是java中的一个关键字，也就是说是Java语言内置的特性。</strong>那么为什么会出现Lock呢？</p>
<ul>
<li>Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。<br />
Lock是一个类，通过这个类可以实现<strong>同步访问</strong>；</li>
<li>Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；<br />
而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。</li>
</ul>
<h3>Lock 的优点</h3>
<p>如果一个代码块被synchronized关键字修饰，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待直至占有锁的线程释放锁。事实上，占有锁的线程释放锁一般会是以下三种情况之一：</p>
<ul>
<li>
<p>占有锁的线程执行完了该代码块，然后释放对锁的占有；</p>
</li>
<li>
<p>占有锁线程执行发生异常，此时JVM会让线程自动释放锁；</p>
</li>
<li>
<p>占有锁线程进入 WAITING 状态从而释放锁，例如在该线程中调用wait()方法等。</p>
</li>
</ul>
<p>试考虑以下三种情况：</p>
<h4>情景1</h4>
<p>在使用synchronized关键字的情形下，假如占有锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程就只能一直等待，别无他法。这会极大影响程序执行效率。</p>
<p>因此，就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间 (解决方案：<code>tryLock(long time, TimeUnit unit)</code>) 或者 能够<strong>响应中断</strong> (解决方案：<code>lockInterruptibly())</code>），这种情况可以通过 Lock 解决。</p>
<h4>情景2</h4>
<p>我们知道，当多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作也会发生冲突现象，但是读操作和读操作不会发生冲突现象。</p>
<p>但是如果采用synchronized关键字实现同步的话，就会导致一个问题，即当多个线程都只是进行读操作时，也只有一个线程在可以进行读操作，其他线程只能等待锁的释放而无法进行读操作。</p>
<p>因此，需要一种机制来使得当多个线程都只是进行读操作时，线程之间不会发生冲突。同样地，Lock也可以解决这种情况 (解决方案：<code>ReentrantReadWriteLock</code>) 。</p>
<h4>情景3</h4>
<p>我们可以通过Lock得知线程有没有成功获取到锁 (解决方案：ReentrantLock) ，但这个是synchronized无法办到的。</p>
<p>上面提到的三种情形，我们都可以通过Lock来解决，但 synchronized 关键字却无能为力。</p>
<p>事实上，Lock 是 java.util.concurrent.locks包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。</p>
<p>也就是说，Lock提供了比synchronized更多的功能。</p>
<h3>Lock接口实现类的使用</h3>
<p>Lock接口有6个方法：</p>
<pre><code class="language-java">// 获取锁  
void lock()   
// 如果当前线程未被中断，则获取锁，可以响应中断  
void lockInterruptibly()   
// 返回绑定到此 Lock 实例的新 Condition 实例  
Condition newCondition()   
// 仅在调用时锁为空闲状态才获取该锁，可以响应中断  
boolean tryLock()   
// 如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁  
boolean tryLock(long time, TimeUnit unit)   
// 释放锁  
void unlock()</code></pre>
<p><code>lock()</code>、<code>tryLock()</code>、<code>tryLock(long time, TimeUnit unit)</code> 和 <code>lockInterruptibly()</code>都是用来获取锁的。</p>
<p>unLock()方法是用来释放锁的。</p>
<p>newCondition() 返回 绑定到此 Lock 的新的 Condition 实例 ，用于线程间的协作</p>
<h4>lock()</h4>
<p>lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。在前面已经讲到，如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。</p>
<p>因此，一般来说，使用Lock必须在try…catch…块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：</p>
<pre><code class="language-java">Lock lock = ...;
lock.lock();
try{
    //处理任务
}catch(Exception ex){

}finally{
    lock.unlock();   //释放锁
}</code></pre>
<h4>tryLock()</h4>
<p>tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true；如果获取失败（即锁已被其他线程获取），则返回false，也就是说，这个方法无论如何都会立即返回（在拿不到锁时不会一直在那等待）。</p>
<p>tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false，同时可以响应中断。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。</p>
<pre><code class="language-java">Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){

}finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}</code></pre>
<h4>lockInterruptibly()</h4>
<p>lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程 正在等待获取锁，则这个线程能够 <strong>响应中断</strong>，即中断线程的等待状态。</p>
<p>例如，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。</p>
<p>由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出 InterruptedException，但推荐使用后者，原因稍后阐述。因此，lockInterruptibly()一般的使用形式如下：</p>
<pre><code class="language-java">public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {  
     //.....
    }
    finally {
        lock.unlock();
    }  
}</code></pre>
<p>注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。</p>
<p>因为interrupt()方法只能中断阻塞过程中的线程而不能中断正在运行过程中的线程。</p>
<p>因此，当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，那么只有进行等待的情况下，才可以响应中断的。</p>
<p>与 synchronized 相比，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。</p>
<h3>ReentrantLock</h3>
<p>ReentrantLock，即 可重入锁。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。下面通过一些实例学习如何使用 ReentrantLock。</p>
<p>构造方法（不带参数 和带参数  true： 公平锁； false: 非公平锁）：</p>
<pre><code class="language-java">    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }</code></pre>
<pre><code class="language-java">import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;
public class LockThread {
    Lock lock = new ReentrantLock(); 
    public void lock(String name) {  
        // 获取锁  
        lock.lock();  
        try {  
            System.out.println(name + " get the lock");  
            // 访问此锁保护的资源  
        } finally {  
            // 释放锁  
            lock.unlock();  
            System.out.println(name + " release the lock");  
        }  
    }

public static void main(String[] args) {
        LockThread lt = new LockThread();  
        new Thread(() -&gt; lt.lock("A")).start();  
        new Thread(() -&gt; lt.lock("B")).start();  
    }
}</code></pre>
<p><img src="https://file.makeyourchoice.cn/2021/10/28/1635414901.png" alt="" style=""><br />
从执行结果可以看出，A线程和B线程同时对资源加锁，A线程获取锁之后，B线程只好等待，直到A线程释放锁B线程才获得锁。</p>
<p>总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点：</p>
<ul>
<li>synchronized是Java语言的关键字，因此是内置特性，Lock不是Java语言内置的，Lock是一个接口，通过实现类可以实现同步访问。</li>
<li>synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定<br />
但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中</li>
<li>在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态。</li>
</ul>
<h3>ReadWriteLock</h3>
<p>ReadWriteLock 接口只有两个方法：</p>
<pre><code class="language-java">//返回用于读取操作的锁  
Lock readLock()   
//返回用于写入操作的锁  
Lock writeLock() </code></pre>
<p>ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。</p>
<p>只要没有 writer，读取锁可以由多个 reader 线程同时保持，而写入锁是独占的。</p>
<p>【例子】三个线程同时对一个共享数据进行读写</p>
<pre><code class="language-java">import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class Queue {
    //共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
    private Object data = null;
    ReadWriteLock lock = new ReentrantReadWriteLock();
    // 读数据
    public void get() {
        // 加读锁
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to read data!");
            Thread.sleep((long) (Math.random() * 1000));
            System.out.println(Thread.currentThread().getName() + " have read data :" + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放读锁
            lock.readLock().unlock();
        }
    }
    // 写数据
    public void put(Object data) {
        // 加写锁
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to write data!");
            Thread.sleep((long) (Math.random() * 1000));
            this.data = data;
            System.out.println(Thread.currentThread().getName() + " have write data: " + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放写锁
            lock.writeLock().unlock();
        }
    }
}
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        final Queue queue = new Queue();
        //一共启动6个线程，3个读线程，3个写线程
        for (int i = 0; i &lt; 3; i++) {
            //启动1个读线程
            new Thread() {
                public void run() {
                    while (true) {
                        queue.get();
                    }
                }
            }.start();
            //启动1个写线程
            new Thread() {
                public void run() {
                    while (true) {
                        queue.put(new Random().nextInt(10000));
                    }
                }
            }.start();
        }
    }
}</code></pre>
<p><img src="https://file.makeyourchoice.cn/2021/10/28/1635421658.png" alt="" style=""></p>
<h3>ReentrantReadWriteLock</h3>
<ul>
<li>位于 <code>java.util.concurrent.locks</code> 包下，它实现了 <code>ReadWriteLock</code> 接口和 <code>Serializable</code> 接口</li>
<li><code>ReentrantReadWriteLock</code>读写锁在<code>ReentrantLock</code>上进行了拓展</li>
<li>读写锁是“<strong>读写互斥，写写互斥，读读共享</strong>” 的锁</li>
<li>读锁和写锁共用同一个 <strong>原子state</strong> 和 <strong>On Sync Queue</strong> 来进行资源控制，它把对共享资源对访问者划分成了读者和写者，读者只对共享资源进行访问，写者则是对共享资源进行写操作</li>
<li>在没有写操作的时候，允许多个线程同时读取共享资源，同一个线程读可以重入（但是同一个线程不可以获取写锁）</li>
<li>如果一个线程想去写这些共享资源，不允许其他线程对该资源进行读和写的操作了（但是同一个线程读写可以重入）</li>
</ul>
<h4>特性</h4>
<ul>
<li>公平选择性：支持非公平（默认）和公平的锁获取方式，<strong>吞吐量还是非公平优于公平</strong></li>
<li>重进入：读锁和写锁都支持线程重入</li>
<li>锁降级：遵循获取写锁、获取读锁再释放写锁的次序，<strong>写锁能够降级成为读锁</strong></li>
<li>锁升级：<strong>读锁是不能直接升级为写入锁的</strong>。因为获取一个写入锁需要释放所有读取锁，所以如果有两个读取锁视图获取写入锁而都不释放读取锁时就会发生死锁</li>
</ul>
<p>线程进入读锁的前提条件：</p>
<ul>
<li>没有任何锁，那么读锁可以立马获取</li>
<li>有读锁，那么读锁可以立马获取</li>
<li>没有其他线程的写锁，那么读锁可以立马获取</li>
<li>有同一线程的写锁，获取读锁会产生锁降级（必须是先获得写锁再获取读锁，不然会造成死锁）</li>
</ul>
<p>线程进入写锁的前提条件：</p>
<ul>
<li>没有任何锁，那么可以立刻获的写锁</li>
<li>没有读锁，没其他线程的写锁，那么可以立刻获的写锁</li>
</ul>
<h4>Sync类的源码</h4>
<ul>
<li>Sync是ReentrantReadWriteLock内部实现的一个内部类，Sync继承了AbstractQueuedSynchronizer（AQS）</li>
<li>Sync将Aqs的state分为高16位，低16位</li>
<li>低16位表示写锁计数（可重入次数），写锁重入个数加1，其实是status状态值加 1</li>
<li>高16位表示持有读锁的线程数（多线程读），读锁个数加1，其实是status状态值加 2^16</li>
<li>写锁用高位部分（即EXCLUSIVE_MASK：65535）&amp;status状态值来计算写锁的重入计数（实际上是将高位的二进制置为0）</li>
</ul>
<h2>ThreadLocal</h2>
<h3>简介</h3>
<p><code>ThreadLocal</code>类主要解决的就是<strong>让每个线程绑定自己的值</strong>，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。</p>
<p>如果你创建了一个<code>ThreadLocal</code>变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是ThreadLocal变量名的由来。他们可以使用 <code>get（）</code> 和 <code>set（）</code> 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。</p>
<h3>原理</h3>
<pre><code class="language-java">public class Thread implements Runnable {
    //......
    //与此线程有关的ThreadLocal值。由ThreadLocal类维护
    ThreadLocal.ThreadLocalMap threadLocals = null;

//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    //......
}</code></pre>
<p>从上面Thread类 源代码可以看出Thread 类中有一个 <code>threadLocals</code> 和 一个 <code>inheritableThreadLocals</code> 变量，它们都是 <code>ThreadLocalMap</code> 类型的变量,我们可以把 ThreadLocalMap 理解为ThreadLocal 类实现的定制化的 <code>HashMap</code>。默认情况下这两个变量都是 null，只有当前线程调用 ThreadLocal 类的 set或get方法时才创建它们，实际上调用这两个方法的时候，我们调用的是ThreadLocalMap类对应的 get()、set()方法。</p>
<p>最终的变量是放在了当前线程的 <code>ThreadLocalMap</code> 中，并不是存在 ThreadLocal 上，ThreadLocal 可以理解为只是ThreadLocalMap的封装，传递了变量值。 ThrealLocal 类中可以通过Thread.currentThread()获取到当前线程对象后，直接通过getMap(Thread t)可以访问到该线程的ThreadLocalMap对象。</p>
<p>每个Thread中都具备一个ThreadLocalMap，而ThreadLocalMap可以存储以ThreadLocal为 key ，Object 对象为 value 的键值对。</p>
<p>比如我们在同一个线程中声明了两个 ThreadLocal 对象的话，会使用 Thread内部都是使用仅有那个ThreadLocalMap 存放数据的，ThreadLocalMap的 key 就是 ThreadLocal对象，value 就是 ThreadLocal 对象调用set方法设置的值。<br />
<img src="https://file.makeyourchoice.cn/2021/09/15/1631694318.png" alt="" style=""></p>
<h3>内存泄露问题</h3>
<ul>
<li>ThreadLocalMap 中使用的 <strong>key 为 ThreadLocal 的弱引用,而 value 是强引用</strong>。</li>
<li>所以，如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候，key 会被清理掉，而 value 不会被清理掉。这样一来，ThreadLocalMap 中就会出现 key 为 null 的 Entry。</li>
<li>假如我们不做任何措施的话，value 永远无法被 GC 回收，这个时候就可能会产生内存泄露。</li>
<li>ThreadLocalMap 实现中已经考虑了这种情况，在调用 set()、get()、remove() 方法的时候，会清理掉 key 为 null 的记录。使用完 ThreadLocal方法后 最好手动调用remove()方法</li>
</ul>
<h2>线程池</h2>
<h3>优点</h3>
<ul>
<li><strong>降低资源消耗</strong>。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。</li>
<li><strong>提高响应速度</strong>。当任务到达时，任务可以不需要的等到线程创建就能立即执行。</li>
<li><strong>提高线程的可管理性</strong>。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。</li>
</ul>
<h3>Executor 框架</h3>
<p>Executor 框架是 Java5 之后引进的，在 Java 5 之后，通过 Executor 来启动线程比使用 Thread 的 start 方法更好，除了<strong>更易管理，效率更好</strong>（用线程池实现，节约开销）外，还有关键的一点：<strong>有助于避免 this 逃逸问题。</strong></p>
<p>Executor 框架的构成：</p>
<h4>任务(Runnable /Callable)</h4>
<p>执行任务需要实现的 <code>Runnable</code> 接口 或 <code>Callable</code>接口。</p>
<p><code>Runnable</code> 接口或<code>Callable</code> 接口 实现类都可以被 <code>ThreadPoolExecutor</code> 或 <code>ScheduledThreadPoolExecutor</code> 执行。</p>
<p><strong>Runnable 接口不会返回结果或抛出检查异常</strong>，但是 Callable 接口可以。<br />
所以，如果任务不需要返回结果或抛出异常推荐使用 Runnable 接口，这样代码看起来会更加简洁。</p>
<p>工具类 Executors 可以实现将 Runnable 对象转换成 Callable 对象。</p>
<h4>任务的执行(Executor)</h4>
<p><img src="https://file.makeyourchoice.cn/2021/10/12/1634005095.png" alt="" style=""></p>
<h4>异步计算的结果(Future)</h4>
<p><code>Future</code> 接口以及 <code>Future</code> 接口的实现类 <code>FutureTask</code> 类都可以代表异步计算的结果。</p>
<ul>
<li>execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；</li>
<li>submit()方法用于提交需要返回值的任务。线程池会返回一个 Future 类型的对象，通过这个 Future 对象可以判断任务是否执行成功 ，并且可以通过 Future 的 get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。</li>
</ul>
<p><code>Callable</code> 接口 的实现类提交给 <code>ThreadPoolExecutor</code> 或 <code>ScheduledThreadPoolExecutor</code> 执行,调用 <code>submit()</code> 方法时会返回一个 <code>FutureTask</code> 对象</p>
<p>主线程可以执行 <code>FutureTask.get()</code>方法来等待任务执行完成。</p>
<p>主线程也可以执行<code>FutureTask.cancel</code>（boolean mayInterruptIfRunning）来取消此任务的执行。</p>
<h3>ThreadPoolExecutor</h3>
<p>线程池实现类 <code>ThreadPoolExecutor</code> 是 <code>Executor</code> 框架最核心的类。</p>
<h4>参数</h4>
<p><code>ThreadPoolExecutor</code> 3 个最重要的参数：</p>
<ul>
<li><code>corePoolSize</code> : 核心线程数线程数定义了最小可以同时运行的线程数量。</li>
<li><code>maximumPoolSize</code> : 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。</li>
<li><code>workQueue</code>: 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。</li>
</ul>
<p><code>ThreadPoolExecutor</code>其他常见参数:</p>
<ul>
<li><code>keepAliveTime</code>:当线程池中的线程数量大于 corePoolSize 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 keepAliveTime才会被回收销毁；</li>
<li><code>unit</code> : keepAliveTime 参数的时间单位。</li>
<li><code>threadFactory</code> :executor 创建新线程的时候会用到。</li>
<li><code>handler</code> :饱和（拒绝）策略。关于饱和策略下面单独介绍一下。</li>
</ul>
<p><code>ThreadPoolExecutor</code> <strong>饱和策略</strong>定义:</p>
<ul>
<li><code>ThreadPoolExecutor.AbortPolicy</code> ：抛出 <code>RejectedExecutionException</code>来拒绝新任务的处理。（默认）</li>
<li><code>ThreadPoolExecutor.CallerRunsPolicy</code> ：调用执行自己的线程运行任务，也就是直接在调用execute方法的线程中运行(run)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。<br />
因此这种策略会降低对于新任务提交速度，影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话，你可以选择这个策略。（对于可伸缩的应用程序，建议使用）</li>
<li><code>ThreadPoolExecutor.DiscardPolicy</code> ：不处理新任务，直接丢弃掉。</li>
<li><code>ThreadPoolExecutor.DiscardOldestPolicy</code> ： 此策略将丢弃最早的未处理的任务请求。</li>
</ul>
<h4>线程池的创建</h4>
<p>推荐使用 ThreadPoolExecutor 构造函数创建线程池，不要使用Executors 去创建<br />
<div class="tip inlineBlock share">

Executors 返回线程池对象的弊端如下：</p>
<p><code>FixedThreadPool</code> 和 <code>SingleThreadExecutor</code> ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致 OOM。</p>
<p><code>CachedThreadPool</code> 和 <code>ScheduledThreadPool</code> ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。
</div></p>
<h4>示例代码</h4>
<p><strong>Runnable+ThreadPoolExecutor</strong><br />
<code>MyRunnable.java</code></p>
<pre><code class="language-java">//这是一个简单的Runnable类，需要大约5秒钟来执行其任务。
public class MyRunnable implements Runnable {
    private String command;
    public MyRunnable(String s) {
        this.command = s;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
        processCommand();
        System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
    }
    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public String toString() {
        return this.command;
    }
}</code></pre>
<p><code>ThreadPoolExecutorDemo.java</code></p>
<pre><code class="language-java">public class ThreadPoolExecutorDemo {
    //核心线程数为 5。
    private static final int CORE_POOL_SIZE = 5;
    //最大线程数 10
    private static final int MAX_POOL_SIZE = 10;
    //任务队列为 ArrayBlockingQueue，并且容量为 100;
    private static final int QUEUE_CAPACITY = 100;
    //等待时间为 1L。
    private static final Long KEEP_ALIVE_TIME = 1L;
    public static void main(String[] args) {
        //使用阿里巴巴推荐的创建线程池的方式
        //通过ThreadPoolExecutor构造函数自定义参数创建
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue&lt;&gt;(QUEUE_CAPACITY),
                ////饱和策略为 CallerRunsPolicy。
                new ThreadPoolExecutor.CallerRunsPolicy());

for (int i = 0; i &lt; 10; i++) {
            //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
            Runnable worker = new MyRunnable("" + i);
            //执行Runnable
            executor.execute(worker);
        }
        //终止线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}</code></pre>
<h3>比较</h3>
<h4>shutdown() VS shutdownNow()</h4>
<ul>
<li><code>shutdown（）</code> :关闭线程池，线程池的状态变为 SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。</li>
<li><code>shutdownNow（）</code> :关闭线程池，线程的状态变为 STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。</li>
</ul>
<h4>isTerminated() VS isShutdown()</h4>
<ul>
<li><code>isShutDown</code> 当调用 <code>shutdown()</code> 方法后返回为 true。</li>
<li><code>isTerminated</code> 当调用 <code>shutdown()</code> 方法后，并且所有提交的任务完成后返回为 true</li>
</ul>
<h4>ScheduledThreadPoolExecutor</h4>
<p><code>ScheduledThreadPoolExecutor</code> 主要用来在给定的延迟后运行任务，或者定期执行任务。<br />
这个在实际项目中基本不会被用到，因为有其他方案选择比如<code>quartz</code>。</p>
<h3>线程池大小确定</h3>
<p><strong>CPU 密集型任务(N+1)</strong>： 这种任务消耗的主要是 CPU 资源，可以将线程数设置为 N（CPU 核心数）+1，比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。<br />
一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。</p>
<p>I/O 密集型任务(2N)： 这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。<br />
因此在 I/O 密集型任务的应用中，我们可以多配置一些线程，具体的计算方法是 2N。</p>
<p><strong>如何判断是 CPU 密集任务还是 IO 密集任务？</strong><br />
CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内存中对大量数据进行排序。<br />
但凡涉及到网络读取，文件读取这类都是 IO 密集型，这类任务的特点是 CPU 计算耗费时间相比于等待 IO 操作完成的时间来说很少，大部分时间都花在了等待 IO 操作完成上。</p>
<h2>Atomic</h2>
<p>这里Atomic原子类是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。</p>
<p><strong>原子类</strong>说简单点就是具有<strong>原子/原子操作特征的类</strong>。</p>
<p>并发包 <code>java.util.concurrent</code> 的原子类都存放在<code>java.util.concurrent.atomic</code>下</p>
<h3>JUC 包中的原子类</h3>
<h4>基本类型</h4>
<p>使用原子的方式更新基本类型</p>
<ul>
<li><code>AtomicInteger</code>：整形原子类</li>
<li><code>AtomicLong</code>：长整型原子类</li>
<li><code>AtomicBoolean</code>：布尔型原子类</li>
</ul>
<h4>数组类型</h4>
<p>使用原子的方式更新数组里的某个元素</p>
<ul>
<li><code>AtomicIntegerArray</code>：整形数组原子类</li>
<li><code>AtomicLongArray</code>：长整形数组原子类</li>
<li><code>AtomicReferenceArray</code>：引用类型数组原子类</li>
</ul>
<h4>引用类型</h4>
<ul>
<li><code>AtomicReference</code>：引用类型原子类</li>
<li><code>AtomicStampedReference</code>：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，<strong>可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题</strong>。</li>
<li><code>AtomicMarkableReference</code> ：原子更新带有标记位的引用类型</li>
</ul>
<h4>对象的属性修改类型</h4>
<ul>
<li><code>AtomicIntegerFieldUpdater</code>：原子更新整形字段的更新器</li>
<li><code>AtomicLongFieldUpdater</code>：原子更新长整形字段的更新器</li>
<li><code>AtomicReferenceFieldUpdater</code>：原子更新引用类型字段的更新器</li>
</ul>
<h3>AtomicInteger 的使用</h3>
<pre><code class="language-java">public final int get() //获取当前的值
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
public final int getAndIncrement()//获取当前的值，并自增
public final int getAndDecrement() //获取当前的值，并自减
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。</code></pre>
<pre><code class="language-java">class AtomicIntegerTest {
    private AtomicInteger count = new AtomicInteger();
    //使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。
    public void increment() {
        count.incrementAndGet();
    }

public int getCount() {
        return count.get();
    }
}</code></pre>
<h3>AtomicInteger 类的原理</h3>
<p>AtomicInteger 类主要利用 <strong>CAS</strong> (compare and swap) + <strong>volatile</strong> 和 <strong>native</strong> 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。</p>
<p><div class="tip inlineBlock share">

CAS 的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是 valueOffset。另外 value 是一个 volatile 变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。
</div></p>
<h2>AQS</h2>
<p>AQS 的全称为（<code>AbstractQueuedSynchronizer</code>），这个类在<code>java.util.concurrent.locks</code>包下面。</p>
<p>AQS 是一个用来<strong>构建锁和同步器的框架</strong>，使用 AQS 能简单且高效地构造出应用广泛的大量的<strong>同步器</strong></p>
<h3>原理</h3>
<ul>
<li>AQS 核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为<strong>有效的工作线程</strong>，并且将共享资源设置为<strong>锁定状态</strong>。</li>
<li>如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制 AQS 是用 <strong>CLH</strong> 队列锁实现的，即<strong>将暂时获取不到锁的线程加入到队列中</strong>。<br />
<div class="tip inlineBlock share">

CLH(Craig,Landin,and Hagersten)队列是一个<strong>虚拟的双向队列</strong>（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点（Node）来实现锁的分配。
</div><br />
<img src="https://file.makeyourchoice.cn/2021/09/15/1631697910.png" alt="" style=""><br />
<strong>AQS 使用一个 int 成员变量来表示同步状态，通过内置的 FIFO 队列来完成获取资源线程的排队工作</strong>。AQS 使用 CAS 对该同步状态进行原子操作实现对其值的修改。</li>
</ul>
<h3>AQS 对资源的共享方式</h3>
<p><strong>AQS 定义两种资源共享方式</strong></p>
<p><code>Exclusive（独占）</code>：只有一个线程能执行，如 ReentrantLock。又可分为公平锁和非公平锁：</p>
<ul>
<li><strong>公平锁</strong>：按照线程在队列中的排队顺序，先到者先拿到锁</li>
<li><strong>非公平锁</strong>：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的</li>
</ul>
<p><code>Share（共享）</code>：多个线程可同时执行，如 CountDownLatch、Semaphore、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。</p>
<p>ReentrantReadWriteLock 可以看成是组合式，因为 ReentrantReadWriteLock 也就是读写锁允许多个线程同时对某一资源进行读。</p>
<p>不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS 已经在顶层实现好了。</p>
<h3>AQS 底层使用了模板方法模式</h3>
<p>同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：</p>
<ul>
<li>使用者继承 AbstractQueuedSynchronizer 并重写指定的方法。（这些重写方法很简单，无非是对于共享资源 state 的获取和释放）</li>
<li>将 AQS 组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。</li>
</ul>
<h3>AQS 组件总结</h3>
<ul>
<li><code>Semaphore</code>(信号量)-允许多个线程同时访问： <code>synchronized</code> 和 <code>ReentrantLock</code> 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。</li>
<li><code>CountDownLatch</code>（倒计时器）： CountDownLatch 是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。</li>
</ul>
<h3>CountDownLatch</h3>
<p>CountDownLatch 的作用就是 <strong>允许 count 个线程阻塞在一个地方，直至所有线程的任务都执行完毕</strong>。</p>
<p>例如：要读取处理 6 个文件，这 6 个任务都是没有执行顺序依赖的任务，但是我们需要返回给用户的时候将这几个文件的处理的结果进行统计整理。</p>
<p>为此我们定义了一个线程池和 count 为 6 的CountDownLatch对象 。使用线程池处理读取任务，每一个线程处理完之后就将 count-1，调用CountDownLatch对象的 await()方法，直到所有文件读取完之后，才会接着执行后面的逻辑。</p>