Java知识体系Java并发编程进阶，多线程和锁底层原理探究 _并发编程

大鹏一日同风起，扶摇直上九万里。这篇文章主要讲述Java知识体系Java并发编程进阶，多线程和锁底层原理探究相关的知识，希望能为你提供帮助。

||To Up||未来村村长正推出一系列【To Up】文章，该系列文章重要是对java开发知识体系的梳理，关注底层原理和知识重点。”天下苦八股文久矣？吾甚哀，若学而作苦，此门无缘，望去之。“该系列与八股文不同，重点在于对知识体系的构建和原理的探究。

文章目录

??||To Up||??
??一、Java多线程??????

??1、进程与线程??

??（1）进程??
??（2）线程??
??（3）线程与进程的区别??

??2、线程的创建??

??（1）继承Thread类??
??（2）实现Runnable接口??
??（3）使用Callable和FutureTask??
??（4）使用线程池创建??

??3、线程的状态与相关操作??

??（1）相关状态与操作??
??（2）守护线程??
??（3）线程组??

??① 创建??
??② 使用??
??③ 线程组的枚举??
??④ main线程组的获取??

??4、线程间通信??
??5、线程池的架构设计??

??（1）线程池架构设计??
??（2）Executors的使用与弊端??

??5、线程池标准创建方式与相关原理??

??（1）ThreadPoolExecutor??

??① 核心和最大线程数量??
??② BlockingQueue??
??③ keepAliveTime??

??（2）向线程池提交任务的两种方式??
??（3）任务调度流程??
??（4）线程工厂ThreadFactory??
??（5）任务阻塞队列??
??（6）线程池的拒绝策略??
??（7）线程池的状态与关闭??

??6、ThreadLocal：线程安全解决??

??（1）ThreadLocal原理??
??（2）与Synchnized区别??
??（3）ThreadLocal成员方法??

??二、Java内置锁??????

??1、synchronized关键字??

??（1）synchronized同步方法??
??（2）synchronized同步块??
??（3）Synchronized的两个推论??

??2、Java内置锁??

??（1）Java对象与内置锁??
??（2）内置锁的状态??

??① 无锁状态??
??② 偏向锁状态??
??③ 轻量级锁状态??
??④ 重量级锁状态??

??3、synchronized执行原理??
??4、CAS??

??（1）原理??
??（2）使用??
??（3）CAS操作的弊端和规避??

??三、JUC显式锁??????

??1、显式锁Lock接口??
??2、可重入锁ReentrantLock??
??3、显式锁的使用??

??（1）使用lock阻塞抢锁??
??（2）使用tryLock非阻塞抢锁??
??（4）使用tryLock限时抢锁??

??4、LockSupport??
??5、锁的类型??

??（1）可重入锁和不可重入锁??
??（2）悲观锁和乐观锁??
??（3）公平锁和非公平锁??
??（4）可中断锁和不可中断锁??
??（5）共享锁和独占锁??
??（6）读写锁??

??四、AQS：显式锁的原理??????

??1、AQS的组成??

??（1）状态标志位??
??（2）队列节点类??
??（3）FIFO双向同步队列??
??（4）钩子方法??

??2、AQS实现锁原理??

??（1）自己实现一个简单锁??
??（2）AQS锁抢占原理??

??① 锁抢占执行过程??
??② acquire??
??③ addWaiter()??
??④ acquireQueued()??

??（3）AQS释放锁原理??

??① 锁释放执行过程??
??② release()??
??② tryRelease()??
??③ unparkSuccessor(h)??

??3、AQS条件队列??

??（1）Condition基本原理??
??（2）await等待方法原理??
??（3）signal唤醒方法原理??

??五、JUC原子类???????

??（1）基本类型原子操作??
??（2）引用类型原子操作??

??六、volatile??????

??1、并发三大问题??

??（1）原子性问题??
??（2）可见性问题??
??（3）有序性问题??

??2、volatile原理??

一、Java多线程???? 1、进程与线程
（1）进程【Java知识体系Java并发编程进阶，多线程和锁底层原理探究】 一个进程是一个程序的一次启动和执行，一个进程一般由程序段、数据段、进程控制块组成：

程序段：代码段，需要执行的指令集合
数据段：需要操作的数据和程序运行时产生的数据
进程控制块：进程的描述信息和控制信息，是进程存在的唯一标志

进程的描述信息：进程ID和进程名称
进程的调度信息：程序的起始地址和通信信息
进程的资源信息：内存信息和文件句柄
进程上下文：CPU寄存器的值、当前程序计数器的值

每当使用Java命令启动一个Java应用程序时，就会启动一个JVM进程，所有的Java程序代码都是以线程运行，JVM找到程序的入口main()方法，然后运行main方法产生一个线程，同时还会启动另外一个GC线程用于垃圾回收。
（2）线程线程是指“进程代码段”的一次顺序执行流程，线程是CPU调度的最小单位，而进程是操作系统资源分配的最小单位，线程之间共享进程的内存空间、系统资源。
线程的组成如下：

线程ID：线程的唯一标识，同一个进程内的线程ID不会重复
线程名称：用于用户识别，若没有显式命名系统会自动分配
线程优先级：表示线程调度的优先级，优先级越高获得CPU的执行机会越大
线程状态：分别为新建（NEW）、可执行（RUNNABLE）、阻塞（BLOCKED）、无限期等待（WAITING）、限时等待（TIMED_WAITING）、结束（TERMINATED）。
线程类型：是否为守护线程

（3）线程与进程的区别线程是“进程代码段”的一次顺序执行流程，一个进程由多个线程组成，一个进程至少有一个线程。线程是CPU调度的最小单位，进程是操作系统分配资源的最小单位。进程之间相互独立，但进程内部的各个线程之间并不完全相互独立。各个线程之间共享进程的方法区内存、堆内存以及系统资源。
2、线程的创建
（1）继承Thread类 Thread类是Java多线程编程的基础，通过继承Thread类创建线程类可以实现线程的创建：

继承Thread类，创建新的线程类
重写run()方法，将需要并发执行的业务代码编写在run()方法中
调用Thread实例的start()方法启动线程
线程启动后，线程的run方法将被JVM执行

Thread类的源码量较大，不作展示分析。我们只需要知道Thread定义了线程的状态以及操作线程的相关方法即可。
（2）实现Runnable接口 Thread也实现了Runnable接口，且Thread中有以下构造方法可通过传入Runnable接口实现对象参数来实现线程的创建。

//系统定义名称
public Thread(Runnable target)
init(null, target, "Thread-" + nextThreadNum(), 0);

//自定义名称创建
public Thread(Runnable target, String name)
init(null, target, name, 0);

则通过实现Runnable接口来创建线程的步骤如下：

定义一个类实现Runnable接口
实现Runnable接口中的run()抽象方法【业务处理逻辑】
通过Thread的构造方法创建线程对象，传入Ruunable实例作为参数
调用Thread实例的start()方法启动线程
线程启动后，线程的run方法将被JVM执行，Thread的run方法将会调用Runnable实例的run方法

这里Thread的run()方法先判断target是否为null，这里的target类型就是Runnable，即我们传入的参数。

public void run()
if (target != null)
target.run();

我们也可以看看Runnable的源码，可以看到Runnable是一个函数式接口，即只有一个方法的接口，其与Thread都来自java.lang包。

package java.lang;
@FunctionalInterface
public interface Runnable
public abstract void run();

（3）使用Callable和FutureTask 在使用Callable和FutureTask之前我们先来看看它们的源码，来认识一下他们。首先是Callable，同样是一个函数式接口，其中的call与run类似，但是其具有返回值，可通过泛型来定义。

package java.util.concurrent;
@FunctionalInterface
public interface Callable< V>
V call() throws Exception;

但是我们知道要创建线程离不开Thread类，所以这里使用了FutureTask进行牵线搭桥。我们可以看到FutureTask类的声明和构造器。

public class FutureTask< V> implements RunnableFuture< V>
public FutureTask(Callable< V> callable)
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable

FutureTask继承了RunnableFuture，其源码如下。所以我们可以想到，通过FutureTask构造器可构造一个Runnable实例，这样就可以传入Thread代理执行。

package java.util.concurrent;
public interface RunnableFuture< V> extends Runnable, Future< V>
void run();

使用Callable和FutureTask创建线程的步骤如下：

创建一个Callable接口的实现类，实现call()方法【编写业务逻辑并设置返回值】
使用Callable实现类的实例构造一个FutureTask实例
使用FutureTask实例作为Thread构造器的参数target创建一个线程
调用Thread实例的start()方法启动新线程，Thread的run方法会执行FutureTask的run方法，最终会调用Callable的call方法

（4）使用线程池创建可以通过Executors工厂类构建线程池，然后通过其execute()【没有返回值，只接收Runnable实例和Thread实例】方法和submit()【可接收有返回值的Callable实例，或Runnable实例和Thread实例】方法实现线程的创建和执行。但生产环境不允许通过Executors创建线程池，需要通过调用ThreadPoolExecutor的构造方法完成。
线程池具体原理与操作后续会进行说明。
3、线程的状态与相关操作
（1）相关状态与操作在Thread源码中使用enum枚举了Thread的六种状态：

NEW（新建）：线程创建，未调用start方法启动，这里会调用相应的init方法进行创建【new】
RUNNABLE（可运行）：线程处于可执行状态，已经在Java虚拟机执行，但还在等其它操作系统资源【start()】

就绪状态：调用start()、CPU时间片用完、sleep()操作结束、join()操作结束、抢到对象锁、调用yield()方法

BLOCKED（阻塞）：线程处于阻塞，线程在等待一个监控锁，特别是多线程下的场景等待另一个线程同步块的释放。【synchronized】
WAITING（等待）：线程处于等待状态，指的是该线程正在等待另一个线程执行某些特定的操作【wait()、join()】
TIMED_WAITING（调校时间的等待）：与时间相关的等待，调用了设定等待时长参数的方法【sleep(xx)、wait(xx)、LockSupport.parkNanos(xx)/parkUntil(xx)】
TERMINATED（终止）：线程执行完毕的状态或执行过程发生了异常

我们可以通过getState()方法获取线程的执行状态，或者通过isAlice()方法判断一个线程是否还存活。

（2）守护线程 JVM进程中的GC线程就是一个守护线程，守护线程的使用有以下要点：

守护线程必须在启动前通过setDaemon()方法将状态设置为true，启动后就不能进行设置，否则报InterruptedException异常
守护线程存在被JVM强制终止的风险，所以在守护线程中尽量不去访问系统资源
守护线程中创建的线程也是守护线程

（3）线程组一组线程或线程组的集合，在多线程情况下，对线程进行分组管理。直接在main方法中运行的线程或线程组，都属于main线程组，在main方法中运行的代码上一级为System线程组，其中线程的上一级为main线程组。
① 创建

ThreadGroup threadGroup01 = new ThreadGroup()

② 使用

Thread thread01 = new Thread(threadGroup01,new ThreadImplentsRunnable(),"thread-01");
Thread thread02 = new Thread(threadGroup01,new ThreadImplentsRunnable(),"thread-02")

③ 线程组的枚举

Thread[] threadList = new Thread[10];
threadGroup.enumerate(threadList);

④ main线程组的获取

ThreadGroup mainGroup = Thread.currentThread().getThreadGroup()

4、线程间通信
线程的通信可以定义为：当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，避免无效的资源争夺。通信方式有：等待-通知、共享内存、管道流。其中[等待-通知]是使用较普遍的通信方式。
Java内置锁可以使用wait()和notify()来实现”等待-通知“的通信方式。使用wait()方法以后，JVM会将当前线程加入该锁监视器的等待集合(WaitSet)。使用notify()后，JVM会唤醒该锁监视器等待集合中的第一条线程，若使用notifyAll会唤醒监视器等待集合的所有线程。
5、线程池的架构设计
Java线程的创建和销毁代价都比较高，频繁的创建和销毁线程非常低效，所以出现了线程池。线程池的好处：

提升性能：不需要自己创建线程，将任务交给线程池去执行，线程池能尽可能使用空闲的线程执行异步任务，对创建的线程实现复用
线程管理：线程池可以对线程进行有效管理，使得异步任务得到高效调度执行

（1）线程池架构设计
① Executor：Executor是Java异步目标任务”执行者“接口，其只包含一个方法execute(Runnable command)。
② ExecutorService：ExecutorService继承Executor，其新增了submit和invoke系列方法，对外提供了异步任务的接收服务。
③ AbstractExecutorService：AbstractExecutorService是一个抽象类，它实现了ExecutorService接口。
④ ThreadPoolExecutor：JUC线程池的核心实现类，线程池预先提供了指定数量的可重用线程，并对每个线程池都维护了一些基础数据统计，方便线程的管理和监控。
⑤ ScheduledExecutorService：继承于ExecutorService，用于完成”延时“和周期性任务的调度线程接口。
⑥ ScheduledThreadPoolExecutor：它提供了ScheduledExecutorService中的”延时执行“和”周期执行“等抽象调度方法的具体实现。
⑦ Executors是一个静态工厂类，提供了快速创建线程池的方法。
（2）Executors的使用与弊端 Java通过Executors工厂类提供了4中快捷创建线程池的方法。

方法名	功能简介
newSingleThreadExecutor()	创建只有一个线程的线程池
newFixedThreadPool(int nThreads)	创建固定大小的线程池
newCachedThreadPool()	创建一个不限制线程数量的线程池，任何提交的任务都立即执行，但空闲线程会得到及时回收
newScheduledThreadPool()	创建一个可定期或延时执行任务的线程池

使用Executors工厂类创建线程池有以下潜在问题：

通过newFixedThreadPool(int nThreads)创建固定大小的线程池或通过newSingleThreadExecutor()创建只有一个线程的线程池，若任务提交速度持续大于任务处理速度，会造成大量的任务等待，等待队列过大会造成内存溢出异常
通过newCachedThreadPool()创建一个不限制线程数量的线程池，若大量任务被启动，则需要创建大量的线程，也可能导致内存溢出异常（OOM，Out Of Memory）
通过newScheduledThreadPool()创建一个可定期或延时执行任务的线程池，同样会因为线程数不设限制，从而导致OOM。

5、线程池标准创建方式与相关原理
（1）ThreadPoolExecutor 企业开发规范会要求使用标准的ThreadPoolExecutor构造工作线程池，其中会使用到其较重要的构造器如下：

public ThreadPoolExecutor(
int corePoolSize,//核心线程数，空闲也不会回收
int maximumPoolSize,//最大线程数
long keepAliveTime,TimeUnit unit,//线程最大空闲时长
BlockingQueue< Runnable> workQueue,//任务的排队队列
ThreadFactory threadFactory,//新线程的产生方式
RejectedExecutionHandler handler//拒绝策略
)

① 核心和最大线程数量线程池执行器根据corePoolSize和maximumPoolSize来自动维护线程池的工作线程，当maximumPoolSize被设置为Integer.MAX_VALUE时，线程池可以接收任意数量的并发任务。corePoolSize和maximumPoolSize可以在运行过程中通过set方法动态更改。
使用线程池可以降低资源消耗，提高相应速度和线程的管理性。但是线程数配置不合理会适得其反。对于不同的任务类型将配置不同的线程数：