之前我们已经认识过"池"：String，字符串常量池；MySQL JDBC，数据库连接池(DataSource)…
线程诞生的原因是进程太重量了，导致创建进程/销毁进程比较低效 (内存资源的申请和释放)！而线程就是共享了内存资源，新的线程复用之前的资源，不必重新申请了 (快了)~~
但是如果线程创建的频率高了，此时线程创建销毁的开销仍然不能忽略！
此时就可以使用线程池来进一步优化这里的速度了！！！
用户态：每个进程都是自己执行自己的逻辑；
内核态：一个系统里只有这一份内核在执行逻辑，这个内核要给所有的进程都提供一些服务！
最终的结论：使用线程池是纯用户态操作，要比创建线程 (经历内核态的操作)要快~~
线程池最大的好处就是减少每次启动、销毁线程的损耗！
总结三点：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo {
public static void main(String[] args) {
ExecutorService pool = Executors.newCachedThreadPool();
pool.submit(new Runnable() {
@Override
public void run() {
System.out.println("这是任务");
}
});
}
}
Executors 创建线程池的几种方式
Executors 本质上是 ThreadPoolExecutor 类的封装。
ThreadPoolExecutor 提供了更多的可选参数，可以进一步细化线程池行为的设定。
1）当新加入一个任务时，先判断当前线程数是否大于核心线程数，如果结果为 false，则新建线程并执行任务；
2）如果结果为 true，则判断任务队列是否已满，如果结果为 false，则把任务添加到任务队列中等待线程执行；
3）如果结果为 true，则判断当前线程数量是否超过最大线程数？如果结果为 false，则新建线程执行此任务；
4）如果结果为 true，执行拒绝策略。
一个线程池可以同时提交N个任务，对应的线程池中有M个线程来负责完成这N个任务，如何把N个任务分配给M个线程呢？
生产者消费者模型正好可以解决这个问题！
先搞一个阻塞队列，每个被提交的任务都被放到阻塞队列中。搞M个线程来取队列元素。如果队列空了，M个线程自然阻塞等待；如果队列不为空，每个线程都取任务、执行任务，完了再来取下一个…直到队列为空，线程继续阻塞~~
注意：
1）阻塞队列能够保证线程安全~
2）Thread的线程跑起来之后，在执行过程中，是不会被提前销毁的！run() 执行完了才会被销毁~
3）线程什么时候结束呢？不用结束！因为无法判定啥时候会有新的线程过来！
一般还是在服务器开发中会更常用到线程池，这时线程池肯定是要持续工作的了~
如果非要结束，单独写一个shutdown方法，强制interrupt所有的工作线程 (如果你要写shutdown，后面是需要操作这些线程实例的，所以需要用数组保存起来)
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
class MyThreadPool {
private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
public void submit(Runnable runnable) throws InterruptedException {
queue.put(runnable);
}
public MyThreadPool(int m) {
// 在构造方法中, 创建出 M 个线程. 负责完成工作.
for (int i = 0; i < m; i++) {
Thread t = new Thread(() -> {
while (true) {
try {
Runnable runnable = queue.take();
runnable.run();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
}
}
}
public class Demo {
public static void main(String[] args) throws InterruptedException {
MyThreadPool pool = new MyThreadPool(10);
for (int i = 0; i < 1000; i++) {
int taskId = i; // i是一直在变化的，所以我们创建一个新的变量在Runnable进行捕获!
pool.submit(new Runnable() {
@Override
public void run() {
System.out.println("执行当前任务: " + taskId + " 当前线程: " + Thread.currentThread().getName());
}
});
}
}
}
标准库里提供的 ThreadPoolExecutor 其实要更复杂一些，尤其是构造方法，可以支持很多参数，可以支持很多选项，让我们来创建出不同风格的线程池~~
标准库里带的拒绝策略：重点
(领导：鹏哥；员工：汤老湿)
1）AbortPolicy：中止策略，线程池会抛出异常并中止执行此任务；
2）CallerRunsPolicy：把任务交给添加此任务的线程来执行；
3）DiscardPolicy：忽略此任务（最新加入的任务）；
4）DiscardOldestPolicy：忽略最先加入队列的任务（最老的任务）。
例题： 使用ThreadPoolExecutor创建一个忽略最新任务的线程池，创建规则：
1.核心线程数为5
2.最大线程数为10
3.任务队列为100
4.拒绝策略为忽略最新任务
代码实现：
public class Thread_Demo {
public static void main(String[] args) throws InterruptedException {
// 依题意创建线程池
ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, // 核心线程数
10, // 最大线程数
3, // 线程空闲时长
TimeUnit.SECONDS, // 线程空闲时长的时间单位
new LinkedBlockingQueue<>(100), // 任务队列
new ThreadPoolExecutor.DiscardPolicy()); // 拒绝策略为忽略最新任务
// 测试执行
for (int i = 0; i < 2000; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "已执行.");
},"thread-" + (i + 1)).start();
}
}
}
