本文关键字：

线程 ， 线程池 ， 单线程 ， 多线程 ， 线程池的益处 ， 线程回收 ， 创立形式 ， 外围参数 ， 底层机制 ， 回绝策略 , 参数设置 , 动静监控 ， 线程隔离

线程和线程池相干的常识，是 Java 学习或者面试中肯定会遇到的知识点，本篇咱们会从线程和过程，并行与并发，单线程和多线程等，始终解说到线程池，线程池的益处，创立形式，重要的外围参数，几个重要的办法，底层实现，回绝策略，参数设置，动静调整，线程隔离等等。次要的纲要如下（本文只波及线程局部，线程池下篇讲）：

过程和线程

从线程到过程

要说线程池，就不得不先讲讲线程，什么是线程？

线程（英语：thread）是操作系统可能进行运算调度的最小单位。它被蕴含在过程之中，是过程中的理论运作单位。

那么问题来了，过程又是什么？

过程是操作系统中进行爱护和资源分配的根本单位。

是不是有点懵，过程摸得着看得见么？具体怎么体现？关上 Windows 的工作管理器或者 Mac 的流动监视器，就能够看到，根本每一个关上的 App 就是一个过程，然而并不是肯定的，一个应用程序可能存在多个过程。

比方上面的 Typora 就显示了两个过程，每个过程前面有一个 PID 是惟一的标识，也是由零碎调配的。除此之外，每个过程都能够看到有多少个线程在执行，比方微信有 32 个线程在执行。重要的一句话：一个程序运行之后至多有一个过程，一个过程能够蕴含多个线程。

<img src=”https://markdownpicture.oss-cn-qingdao.aliyuncs.com/blog/image-20210508225417275.png” alt=”image-20210508225417275″ style=”zoom:50%;” />

为什么须要过程？

程序，就是指令的汇合，指令的汇合说白了就是文件，让程序跑起来，在执行的程序，才是过程。程序是动态的形容文本，而过程是程序的一次执行流动，是动静的。过程是领有计算机调配的资源的运行程序。

咱们不可能一个计算机只有一个过程，就跟咱们全国不可能只有一个市或者一个部门，计算机是一个硕大无朋，外面的运行须要有条理，就须要依照性能划分出比拟独立的单位，离开治理。每个过程有本人的职责，也有本人的独立内存空间，不可能混着应用，要是所有的程序共用一个过程就会乱套。

每个过程，都有各自独立的内存，过程之间内存地址隔离，过程的资源，比方：代码段，数据集，堆等等，还可能包含一些关上的文件或者信号量，这都是每个过程本人的数据。同时，因为过程的隔离性，即便有一个程序的过程呈现问题了，个别不会影响到其余的过程的应用。

过程在 Linux 零碎中，过程有一个比拟重要的货色，叫过程管制块（PCB），仅做理解：

PCB是过程的惟一标识，由链表实现，是为了动静的插入以及删除，创立过程的时候，生成一个 PCB，过程完结的时候，回收这个PCB。PCB 次要包含以下的信息：

• 过程状态
• 过程标识信息
• 定时器
• 用户可见的寄存器，管制状态存放区，栈指针等等。

过程怎么切换的呢？

先明确计算机外面的一个事实：CPU 运行得超级无敌快 ，快到其余的只有寄存器差不多能匹配它的速度，然而很多时候咱们须要从磁盘或者内存读或者写数据，这些设施的速度太慢了，与之相差太远。（ 如果不非凡阐明，默认是单核的 CPU）

假如一个程序 / 过程的工作执行一段时间，要写磁盘，写磁盘不须要 CUP 进行计算，那 CPU 就空进去了，然而其余的程序也不能用，CPU就干等着，等到写完磁盘再接着执行。这多节约，CPU又不是这个程序一家的，其余的利用也要应用。CPU你不必的时候，总有他人须要用。

所以 CPU 资源须要调度，程序 A 不必的时候，能够切出来，让程序 B 去应用，然而程序 A 切回来的时候怎么保障它可能接着之前的地位继续执行呢？这时候不得不提 上下文 的事。

当程序 A（假如为单过程）放弃CPU 的时候，须要保留以后的上下文，何为上下文？也就是除了 CPU 之外，寄存器或者其余的状态，就跟犯罪现场一样，须要拍个照，要不到时候别的程序执行完之后，怎么晓得接下来怎么执行程序 A，之前执行到哪一步了。 总结一句话：保留以后程序的执行状态。

上下文切换个别还波及缓存的开销，也就是缓存会生效，个别执行的时候，CPU 会缓存一些数据不便下次更快的执行，一旦进行上下文切换，原来的缓存就生效了，须要从新缓存。

调度个别有两种（个别是依照线程维度来调度）,CPU的工夫被分为特地小的工夫片：

• 分时调度：每个线程或者过程轮流的应用CPU，均匀工夫调配到每个线程或者过程。
• 抢占式调度：优先级高的线程 / 过程立刻抢占下一个工夫片，如果优先级雷同，那么随机抉择一个过程。

工夫片超级短，CPU 超级快，给咱们无比丝滑的感觉，就像是多个工作在同时进行

咱们当初操作系统或者其余的零碎，根本都是抢占式调度，为什么？

因为如果应用分时调度，很难做到实时响应，当后盾的聊天程序在进行网络传输的时候，调配予它的工夫片还没有应用完，那我点击浏览器，是没有方法实时响应的。除此之外，如果后面的过程挂了，然而始终占有CPU，那么前面的工作将永远得不到执行。

因为 CPU 的解决能力超级快，就算是单核的 CPU，运行着多个程序，多个过程，通过抢占式的调度，每一个程序应用的时候都像是独享了CPU 一样顺滑。过程无效的进步了 CPU 的使用率，然而过程在上下文切换的时候是存在着肯定的老本的。

线程和过程什么关系？

后面说了过程，那有了过程，为啥还要线程，多个应用程序，假如咱们每个应用程序要做 n 件事，就用 n 个过程不行么？

能够，然而没必要。

过程个别由程序，数据汇合和过程管制块组成，同一个应用程序个别是须要应用同一个数据空间的，要是一个应用程序搞很多个过程，就算有能力做到数据空间共享，过程的上下文切换都会耗费很多资源。（个别一个应用程序不会有很多过程，大多数一个，多数有几个）

过程的颗粒度比拟大，每次执行都须要上下文切换，如果同一个程序外面的代码段 A，B，C，做不一样的货色，如果分给多个过程去解决，那么每次执行都有切换过程上下文。这太惨了。 一个应用程序的工作是一家人，住在同一个屋子下（同一个内存空间），有必要每个房间都当成每一户，去派出所注销成一个户口么？

过程毛病：

• 信息共享难，空间独立
• 切换须要fork()，切换上下文，开销大
• 只能在一个工夫点做一件事
• 如果过程阻塞了，要期待网络传过来数据，那么其余不依赖这个数据的工作也做不了

然而有人会说，那我一个应用程序有很多事件要做，总不能只用一个过程，所有事件都等着它来解决啊？那不是会阻塞住么？

的确啊，独自一个过程解决不了问题，那么咱们 把过程分得更小，外面分成很多线程，一家人，每个人都有本人的事件做，那咱们每个人就是一个线程，一家人就是一个过程，这样岂不是更好么？

过程是形容 CPU 工夫片调度的工夫片段，然而线程是更细小的工夫片段，两者的颗粒度不一样。线程能够称为轻量级的过程。其实，线程也不是一开始就有的概念，而是随着计算机倒退，对多个工作上下文切换要求越来越高，随之形象进去的概念。
$$ 过程时间段 = CPU 加载程序上下文的工夫 + CPU 执行工夫 + CPU 保留程序上下文的工夫 $$

$$
线程时间段 = CPU 加载线程上下文的工夫 + CPU 执行工夫 + CPU 保留线程上下文的工夫 $$
** 最重要的是，过程切换上下文的工夫远比线程切换上下文的工夫老本要高 **，如果是同一个过程的不同线程之间抢占到 `CPU`，切换老本会比拟低，因为他们 ** 共享了过程的地址空间 **，线程间的通信容易很多，通过共享过程级全局变量即可实现。

况且，当初多核的处理器，让不同过程在不同核上跑，过程内的线程在同个核上做切换，尽量减少（不能够防止）过程的上下文切换，或者让不同线程跑在不同的处理器上，进一步提高效率。

过程和线程的模型如下：


### 线程和过程的区别或者长处

– 线程是程序执行的最小单位，过程是操作系统分配资源的最小单位。
– 一个利用可能多个过程，一个过程由一个或者多个线程组成
– 过程互相独立，通信或者沟通老本高，在同一个过程下的线程共享过程的内存等，相互之间沟通或者合作成本低。
– 线程切换上下文比过程切换上下文要快得多。

## 线程有哪些状态

当初咱们所说的是 `Java` 中的线程 `Thread`, 一个线程在一个给定的工夫点，只能处于一种状态，这些状态都是虚拟机的状态，不能反映任何操作系统的线程状态，一共有六种 / 七种状态：

– `NEW`：创立了线程对象，然而还没有调用 `Start()` 办法，还没有启动的线程处于这种状态。
– `Running`：运行状态，其实蕴含了两种状态，然而 `Java` 线程将就绪和运行中统称为可运行
– `Runnable`：就绪状态：创建对象后，调用了 `start()` 办法，该状态的线程还位于可运行线程池中，期待调度，获取 `CPU` 的使用权
– 只是有资格执行，不肯定会执行
– `start()` 之后进入就绪状态，`sleep()` 完结或者 `join()` 完结，线程取得对象锁等都会进入该状态。
– `CPU` 工夫片完结或者被动调用 `yield()` 办法，也会进入该状态
– `Running`：获取到 `CPU` 的使用权（取得 CPU 工夫片），变成运行中

– `BLOCKED`：阻塞，线程阻塞于锁，期待监视器锁，个别是 `Synchronize` 关键字润饰的办法或者代码块
– `WAITING`：进入该状态，须要期待其余线程告诉（`notify`）或者中断，一个线程无限期地期待另一个线程。
– `TIMED_WAITING`：超时期待，在指定工夫后主动唤醒，返回，不会始终期待
– `TERMINATED`：线程执行结束，曾经退出。如果已终止再调用 start()，将会抛出 `java.lang.IllegalThreadStateException` 异样。


能够看到 `Thread.java` 外面有一个 `State` 枚举类，枚举了线程的各种状态(`Java` 线程将 ** 就绪 ** 和 ** 运行中 ** 统称为 ** 可运行 **)：

“`Java

public enum State {
/**
* 尚未启动的线程的线程状态。
*/
NEW,

/**
* 可运行线程的线程状态，一个处于可运行状态的线程正在 Java 虚拟机中执行，但它可能正在期待来自操作系统 (如处理器) 的其余资源。
*/
RUNNABLE,

/**
* 期待监视器锁而阻塞的线程的线程状态。
* 处于阻塞状态的线程正在期待一个监视器锁进入一个同步的块 / 办法，或者在调用 Oject.wait()办法之后从新进入一个同步代码块
*/
BLOCKED,

/**
* 期待线程的线程状态，线程因为调用其中一个线程而处于期待状态
*/
WAITING,

/**
* 具备指定等待时间的期待线程的线程状态，线程因为调用其中一个线程而处于定时期待状态。
*/
TIMED_WAITING,

/**
* 终止线程的线程状态，线程曾经实现执行。
*/
TERMINATED;
}
“`

除此之外，Thread 类还有一些属性是和线程对象无关的：

– long tid：线程序号
– char name[]：线程名称
– int priority：线程优先级
– boolean daemon：是否守护线程
– Runnable target：线程须要执行的办法

介绍一下下面图中解说到线程的几个重要办法，它们都会导致线程的状态产生一些变动：

– `Thread.sleep(long)`: 调用之后，线程进入 `TIMED_WAITING` 状态，然而不会开释对象锁，到工夫昏迷后进入 `Runnable` 就绪状态
– `Thread.yield()`: 线程调用该办法，示意放弃获取的 `CPU` 工夫片，然而不会开释锁资源，同样变成就绪状态，期待从新调度，不会阻塞，然而也不能保障肯定会让出 `CPU`，很可能又被从新选中。
– `thread.join(long)`: 以后线程调用其余线程 `thread` 的 `join()` 办法，以后线程不会开释锁，会进入 `WAITING` 或者 `TIMED_WAITING` 状态，期待 thread 执行结束或者工夫到，以后线程进入就绪状态。
– `object.wait(long)`: 以后线程调用对象的 `wait()` 办法，以后线程会开释取得的对象锁，进入期待队列，`WAITING`，等到工夫到或者被唤醒。
– `object.notify()`：唤醒在该对象监视器上期待的线程，随机挑一个
– `object.notifyAll()`：唤醒在该对象监视器上期待的所有线程

## 单线程和多线程

单线程，就是只有一条线程在执行工作，串行的执行，而多线程，则是多条线程同时执行工作，所谓同时，并不是肯定真的同时，如果在单核的机器上，就是假同时，只是看起来同时，实际上是轮流占据 CPU 工夫片。

上面的每一个格子是一个工夫片（每一个工夫片实际上超级无敌短），不同的线程其实能够抢占不同的工夫片，取得执行权。** 工夫片调配的单位是线程，而不是过程，过程只是容器 **


### 如何启动一个线程

其实 `Java` 的 `main()` 办法实质上就启动了一个线程，然而 ** 实质上不是只有一个线程 **，看后果的 5 就大抵晓得，其实一共有 5 个线程，主线程是第 5 个, 大多是 ** 后盾线程 **：

“`java
public class Test {
public static void main(String[] args) {
System.out.println(Thread.currentThread().toString());
}
}
“`

执行后果：

“`txt
Thread[main,5,main]
“`

能够看出下面的线程是 `main` 线程，然而要想创立出有别于 `main` 线程的形式，有四种：

– 自定义类去实现 `Runnable` 接口
– 继承 `Thread` 类，重写 `run()` 办法
– 通过 `Callable` 和 `FutureTask` 创立线程
– 线程池间接启动（实质上不算是）

#### 实现 Runnable 接口

“`java
class MyThread implements Runnable{
@Override
public void run(){
System.out.println(“Hello world”);
}
}
public class Test {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread());
thread.start();
System.out.println(“Main Thread”);
}
}
“`

运行后果：

“`txt
Main Thread
Hello world
“`

如果看底层就能够看到，构造函数的时候，咱们将 `Runnable` 的实现类对象传递进入, 会将 `Runnable` 实现类对象保留下来：

“`java
public Thread(Runnable target) {
this(null, target, “Thread-” + nextThreadNum(), 0);
}
“`

而后再调用 `start()` 办法的时候, 会调用原生的 `start0()` 办法，原生办法是由 `c` 或者 `c++` 写的, 这里看不到具体的实现：

“`java
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {
// 正式的调用 native 原生办法
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
“`

`Start0()` 在底层的确调用了 `run()` 办法，并且不是间接调用的，而是启用了另外一个线程进行调用的，这一点在代码正文外面写得比较清楚，在这里咱们就不开展讲，咱们将关注点放到 `run()` 办法上，调用的就是刚刚那个 `Runnable` 实现类的对象的 `run()` 办法:

“`java
@Override
public void run() {
if (target != null) {
target.run();
}
}
“`

#### 继承 Thread 类

因为 `Thread` 类自身就实现了 `Runnable` 接口，所以咱们只有继承它就能够了：

“`java
class Thread implements Runnable {
}
“`

继承之后重写 run()办法即可：

“`java
class MyThread extends Thread{
@Override
public void run(){
System.out.println(“Hello world”);
}
}
public class Test {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread());
thread.start();
System.out.println(“Main Thread”);
}
}
“`

执行后果和下面的一样，其实两种形式实质上都是一样的，一个是实现了 `Runnable` 接口，另外一个是继承了实现了 `Runnable` 接口的 `Thread` 类。两种都没有返回值，因为 `run()` 办法的返回值是 `void`。

#### Callable 和 FutureTask 创立线程

要应用该形式，依照以下步骤：

– 创立 `Callable` 接口的实现类，实现 `call()` 办法
– 创立 `Callable` 实现类的对象实例，用 `FutureTask` 包装 Callable 的实现类实例，包装成 `FutureTask` 的实例，`FutureTask` 的实例封装了 `Callable` 对象的 `Call()` 办法的返回值
– 应用 `FutureTask` 对象作为 `Thread` 对象的 `target` 创立并启动线程，`FutureTask` 实现了 `RunnableFuture`，`RunnableFuture` 继承了 `Runnable`
– 调用 `FutureTask` 对象的 `get()` 来获取子线程执行完结的返回值

“`java
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableTest {
public static void main(String[] args) throws Exception{

Callable<String> callable = new MyCallable<String>();
FutureTask<String> task = new FutureTask<String>(callable);

Thread thread = new Thread(task);
thread.start();

System.out.println(Thread.currentThread().getName());
System.out.println(task.get());

}
}

class MyCallable<String> implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println(
Thread.currentThread().getName() +
” Callable Thread”);
return (String) “Hello”;
}
}
“`

执行后果：

“`txt
main
Thread-0 Callable Thread
Hello
“`

其实这种形式实质上也是 `Runnable` 接口来实现的，只不过做了一系列的封装，然而不同的是，它能够实现返回值，如果咱们期待一件事件能够通过另外一个线程来获取后果，然而可能须要耗费一些工夫，比方异步网络申请，其实能够思考这种形式。

`Callable` 和 `FutureTask` 是前面才退出的性能，是为了适应多种并发场景，`Callable` 和 `Runnable` 的区别如下：

– `Callable` 定义方法是 `call()`，`Runnable` 定义的办法是 `run()`
– `Callable` 的 `call()` 办法有返回值，`Runnable` 的 `run()` 办法没有返回值
– `Callable` 的 `call()` 办法能够抛出异样，`Runnable` 的 `run()` 办法不能抛出异样

#### 线程池启动线程

实质上也是通过实现 `Runnable` 接口，而后放到线程池中进行执行：

“`java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ” : hello world”);
}
}

public class Test {
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
MyThread thread = new MyThread();
executorService.execute(thread);
}
executorService.shutdown();
}
}
“`

执行后果如下，能够看到五个外围线程始终在执行，没有法则，循环十次，然而并没有创立出十个线程，这和线程池的设计以及参数无关，前面会解说：

“`txt
pool-1-thread-5 : hello world
pool-1-thread-4 : hello world
pool-1-thread-5 : hello world
pool-1-thread-3 : hello world
pool-1-thread-2 : hello world
pool-1-thread-1 : hello world
pool-1-thread-2 : hello world
pool-1-thread-3 : hello world
pool-1-thread-5 : hello world
pool-1-thread-4 : hello world
“`

总结一下，启动一个线程，其实实质上都离不开 `Runnable` 接口，不论是继承还是实现接口。

### 多线程可能带来的问题

– 耗费资源：上下文切换，或者创立以及销毁线程，都是比拟耗费资源的。
– 竞态条件：多线程拜访或者批改同一个对象，假如自增操作 `num++`，操作分为三步，读取 `num`，`num` 加 1，写回 `num`，并非原子操作，那么多个线程之间穿插运行，就会产生不如预期的后果。
– 内存的可见性：每个线程都有本人的内存（缓存），个别批改的值都放在本人线程的缓存上，到刷新至主内存有肯定的工夫，所以可能一个线程更新了，然而另外一个线程获取到的还是久的值，这就是不可见的问题。
– 执行程序难预知：线程先 `start()` 不肯定先执行，是由零碎决定的，会导致共享的变量或者执行后果错乱

## 并发与并行

并发是指两个或多个事件在同一时间距离产生，比方在同 `1s` 中内计算机不仅计算 ` 数据 1`，同时也计算了 ` 数据 2`。然而两件事件可能在某一个时刻，不是真的同时进行，很可能是抢占工夫片就执行，抢不到就他人执行，然而因为工夫片很短，所以在 1s 中内，看似是同时执行实现了。当然后面说的是单核的机器，并发不是真的同时执行，然而多核的机器上，并发也可能是真的在同时执行，只是有可能，这个时候的并发也叫做并行。


并行是指在同一时刻，有多条指令在多个处理器上同时执行，真正的在同时执行。


如果是单核的机器，最多只能并发，不可能并行处理，只能把 CPU 运行工夫分片，调配给各个线程执行，执行不同的线程工作的时候须要上下文切换。而多核机器，能够做到真的并行，同时在多个核上计算，运行。** 并行操作肯定是并发的，然而并发的操作不肯定是并行的。**

### 对于作者
秦怀，公众号【** 秦怀杂货店 **】作者，技术之路不在一时，山高水长，纵使迟缓，驰而不息。集体写作方向：Java 源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指 Offer，LeetCode 等，认真写好每一篇文章，不喜爱题目党，不喜爱花里胡哨，大多写系列文章，不能保障我写的都完全正确，然而我保障所写的均通过实际或者查找材料。脱漏或者谬误之处，还望斧正。

[2020 年我写了什么？](http://aphysia.cn/archives/2020)

[开源编程笔记](https://damaer.github.io/Coding/#/)

[150 页的剑指 Offer PDF 支付](https://mp.weixin.qq.com/s?__biz=MzA3NTUwNzk0Mw==&tempkey=MTExNF9zZ2FPelJtWkNCdlZ6dTRuVThBSDdNc01JNFZuSTBrVlZWU0dCRk45dzlLVmx3SWx3NXlHVE5DWkRTSFBnNWVhRFV6RkNKOURjSmhUTExZeVp4QndwbEZ4Q2NfWUlzMzI2bDQzSm51TVJ4SE14QVhsUFIxSWJkcWtGQVhhLVVwZGRPZ0cwRHFDaGJvZ2pPeDM3NXdzcGF5N3A5bFdRaE9JU1Rpbi1Rfn4%3D&chksm=383018090f47911fd2458fe7c2ee89cbde7a7875dcba06d9f2e4daca191c7c0ab6409777f14d#rd)