前言
每一个线程的启动和结束都是比较消耗时间和占用资源的。
如果在系统中使用到了很多的线程，大量的启动和结束动作会导致系统的性能变卡，响应变慢。
为了解决这个问题，引入线程池这种设计思想。
线程池的模式很像生产者消费者模式，消费的对象是一个一个能够运行的任务。
一、线程池设计思路
线程池的思路和生产者消费者模型是很接近的：
1、准备一个任务容器
2、一次性启动 10 个消费者线程
3、刚开始任务容器是空的，所以线程都 wait 在上面
4、直到一个外部线程往这个任务容器中扔了一个任务，就会有一个消费者线程被唤醒 notify
5、这个消费者线程取出任务，并且执行这个任务，执行完毕后，继续等待下一次任务的到来。
6、如果短时间内，有较多的任务加入，那么就会有多个线程被唤醒，去执行这些任务。
在整个过程中，都不需要创建新的线程，而是循环使用这些已经存在的线程
如下图：
二、开发一个自定义线程池
如下代码实现，虽然不够完善和健壮，但是已经足以说明线程池的工作原理：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
public class ThreadPool {
private int threadPoolSize;
private LinkedList<Runnable> tasks = new LinkedList<>();
public ThreadPool(){
threadPoolSize = 10;
synchronized (tasks){
for (int i = 0; i < threadPoolSize; i++) {
new TaskConsumeThread("任务消费者线程 " + i).start();
}
}
}
public void add(Runnable runnable){
synchronized (tasks){
tasks.add(runnable);
tasks.notifyAll();
}
}
class TaskConsumeThread extends Thread{
private Runnable task;
public TaskConsumeThread(@NonNull String name) {
super(name);
}
@Override
public void run() {
System.out.println("启动：" + getName());
while (true){
synchronized (tasks){
while (tasks.isEmpty()){
try {
tasks.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
task = tasks.removeLast();
tasks.notifyAll();
}
System.out.println(getName() + " 获取到任务，并执行");
task.run();
}
}
}
}
public class TestThread {
public static void main(String[] args) {
ThreadPool pool = new ThreadPool();
for (int i = 0; i < 5; i++) {
int finalI = i;
Runnable task = new Runnable() {
@Override
public void run() {
System.out.println("执行任务：" + finalI);
}
};
pool.add(task);
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
启动：任务消费者线程 0
启动：任务消费者线程 2
启动：任务消费者线程 1
启动：任务消费者线程 3
启动：任务消费者线程 5
启动：任务消费者线程 6
启动：任务消费者线程 7
启动：任务消费者线程 8
启动：任务消费者线程 4
启动：任务消费者线程 9
任务消费者线程 7 获取到任务，并执行
任务消费者线程 2 获取到任务，并执行
任务消费者线程 9 获取到任务，并执行
任务消费者线程 0 获取到任务，并执行
执行任务：3
执行任务：0
执行任务：2
任务消费者线程 1 获取到任务，并执行
执行任务：1
执行任务：4
|
三、测试线程池
创造一个情景，每个任务执行的时间都是 1 秒，刚开始是间隔 1 秒钟向线程池中添加任务，然后间隔时间越来越短，执行任务的线程还没来得及结束，新的任务又来了。此时就会观察到线程池里的其他线程被唤醒来执行这些任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
| public class TestThread {
public static void main(String[] args) {
ThreadPool pool = new ThreadPool();
int sleep = 1000;
while (true) {
pool.add(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
try {
Thread.sleep(sleep);
sleep = sleep > 100 ? sleep - 100 : sleep;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
启动：任务消费者线程 0
启动：任务消费者线程 3
启动：任务消费者线程 4
启动：任务消费者线程 2
启动：任务消费者线程 1
启动：任务消费者线程 5
启动：任务消费者线程 6
启动：任务消费者线程 7
启动：任务消费者线程 8
启动：任务消费者线程 9
任务消费者线程 8 获取到任务，并执行
任务消费者线程 4 获取到任务，并执行
任务消费者线程 7 获取到任务，并执行
任务消费者线程 8 获取到任务，并执行
任务消费者线程 4 获取到任务，并执行
任务消费者线程 7 获取到任务，并执行
任务消费者线程 8 获取到任务，并执行
任务消费者线程 4 获取到任务，并执行
任务消费者线程 6 获取到任务，并执行
任务消费者线程 7 获取到任务，并执行
任务消费者线程 5 获取到任务，并执行
任务消费者线程 8 获取到任务，并执行
任务消费者线程 9 获取到任务，并执行
任务消费者线程 0 获取到任务，并执行
任务消费者线程 1 获取到任务，并执行
任务消费者线程 4 获取到任务，并执行
任务消费者线程 2 获取到任务，并执行
任务消费者线程 3 获取到任务，并执行
任务消费者线程 6 获取到任务，并执行
任务消费者线程 7 获取到任务，并执行
任务消费者线程 5 获取到任务，并执行
任务消费者线程 8 获取到任务，并执行
任务消费者线程 9 获取到任务，并执行
任务消费者线程 0 获取到任务，并执行
...
|
四、使用 Java 自带线程池
Java 给我们提供了自带的线程池 ThreadPoolExecutor 在 java.util.concurrent 包下。
如下代码：
1
2
3
4
5
6
7
| ThreadPoolExecutor pool = new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
pool.execute(new Runnable() {
@Override
public void run() {
System.out.println("执行任务");
}
});
|
第一个参数 10 ：表示线程池初始化了 10 线程在里面工作
第二个参数 15 ：表示如果 10 个线程不够用了，就会增加到最多 15 个线程
第三个参数 60 ：结合第四个参数 TimeUnit.SECONDS 表示 经过 60 秒，多出来的线程没有接到活，就会回收，最后保持池子里面就 10 个
第四个参数 TimeUnit.SECONDS 如上
第五个参数 new LinkedBlockingQueue<>() ：表示存放任务的集合
execute 方法用于添加并执行新的任务
五、总结
本篇文章我们介绍了：
1、设计一个线程池的思路并进行了具体实现
2、自定义线程池测试
3、Java 自带线程池介绍
好了，本篇文章到这里就结束了，感谢你的阅读🤝