pool-1-thread-1 is running…
pool-1-thread-1 is running…
pool-1-thread-1 is running…
底层实现
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new linkedBlockingQueue()));
}
从参数可以看出来，SingleThreadExecutor 相当于特殊的 FixedThreadPool，它的执行流程如下：
-
线程池中没有线程时，新建一个线程执行任务
-
有一个线程以后，将任务加入阻塞队列，不停的加
-
唯一的这一个线程不停地去队列里取任务执行
SingleThreadExecutor 用于串行执行任务的场景，每个任务必须按顺序执行，不需要并发执行。
newFixedThreadPool
public class FixedThreadPoolTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
MyRunnable myRunnable = new MyRunnable();
for (int i = 0; i < 5; i++) {
executorService.execute(myRunnable);
}
System.out.println(“线程任务开始执行”);
executorService.shutdown();
}
}
输出结果
线程任务开始执行
pool-1-thread-1 is running…
pool-1-thread-1 is running…
pool-1-thread-2 is running…
pool-1-thread-1 is running…
pool-1-thread-2 is running…
底层实现
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new linkedBlockingQueue());
}
可以看到，FixedThreadPool 的核心线程数和最大线程数都是指定值，也就是说当线程池中的线程数超过核心线程数后，任务都会被放到阻塞队列中。
此外 keepAliveTime 为 0，也就是多余的空余线程会被立即终止（由于这里没有多余线程，这个参数也没什么意义了）。
而这里选用的阻塞队列是 linkedBlockingQueue，使用的是默认容量 Integer.MAX_VALUE，相当于没有上限。
因此这个线程池执行任务的流程如下：
-
线程数少于核心线程数，也就是设置的线程数时，新建线程执行任务
-
线程数等于核心线程数后，将任务加入阻塞队列
-
由于队列容量非常大，可以一直加
-
执行完任务的线程反复去队列中取任务执行
FixedThreadPool 用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量。
newCachedThreadPool
public class CachedThreadPoolTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
MyRunnable myRunnable = new MyRunnable();
for (int i = 0; i < 5; i++) {
executorService.execute(myRunnable);
}
System.out.println(“线程任务开始执行”);
executorService.shutdown();
}
}
输出结果
线程任务开始执行
pool-1-thread-1 is running…
pool-1-thread-4 is running…
pool-1-thread-2 is running…
pool-1-thread-5 is running…
pool-1-thread-3 is running…
底层实现
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue());
}
可以看到，CachedThreadPool 没有核心线程，非核心线程数无上限，也就是全部使用外包，但是每个外包空闲的时间只有 60 秒，超过后就会被回收。
CachedThreadPool 使用的队列是 SynchronousQueue，这个队列的作用就是传递任务，并不会保存。
因此当提交任务的速度大于处理任务的速度时，每次提交一个任务，就会创建一个线程。极端情况下会创建过多的线程，耗尽 CPU 和内存资源。
它的执行流程如下：
-
没有核心线程，直接向 SynchronousQueue 中提交任务
-
如果有空闲线程，就去取出任务执行；如果没有空闲线程，就新建一个
-
执行完任务的线程有 60 秒生存时间，如果在这个时间内可以接到新任务，就可以继续活下去，否则就拜拜
-
由于空闲 60 秒的线程会被终止，长时间保持空闲的 CachedThreadPool 不会占用任何资源。
CachedThreadPool 用于并发执行大量短期的小任务，或者是负载较轻的服务器。
newScheduledThreadPool
public class ScheduledThreadPoolTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
MyRunnable myRunnable = new MyRunnable();
for (int i = 0; i < 5; i++) {
// 参数1:目标对象,参数2:隔多长时间开始执行线程,参数3:执行周期,参数4:时间单位
scheduledExecutorService.scheduleAtFixedRate(myRunnable, 1, 2, TimeUnit.SECONDS);
}
System.out.println(“线程任务开始执行”);
}
}
输出结果
线程任务开始执行
// 打印【线程任务开始执行】后1秒输出
pool-1-thread-1 is running…
pool-1-thread-2 is running…
pool-1-thread-1 is running…
pool-1-thread-3 is running…
pool-1-thread-2 is running…
// 2秒后输出
pool-1-thread-1 is running…
pool-1-thread-3 is running…
pool-1-thread-2 is running…
pool-1-thread-1 is running…
pool-1-thread-3 is running…
底层实现
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}
ScheduledThreadPoolExecutor 的执行流程如下：
-
添加一个任务
-
线程池中的线程从 DelayQueue 中取任务
-
然后执行任务
具体执行任务的步骤也比较复杂：
-
线程从 DelayQueue 中获取 time 大于等于当前时间的 ScheduledFutureTask
-
执行完后修改这个 task 的 time 为下次被执行的时间
-
然后再把这个 task 放回队列中
ScheduledThreadPoolExecutor 用于需要多个后台线程执行周期任务，同时需要限制线程数量的场景。
Executors和ThreaPoolExecutor创建线程池的区别
Executors 各个方法的弊端：
- newFixedThreadPool 和 newSingleThreadExecutor:
主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至 OOM。
- newCachedThreadPool 和 newScheduledThreadPool:
主要问题是线程数最大数是 Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至 OOM。
ThreaPoolExecutor
- 创建线程池方式只有一种，就是走它的构造函数，参数自己指定
两种提交任务的方法
ExecutorService 提供了两种提交任务的方法：
-
execute()：提交不需要返回值的任务
-
submit()：提交需要返回值的任务
void execute(Runnable command);
execute() 的参数是一个 Runnable，也没有返回值。因此提交后无法判断该任务是否被线程池执行成功。
ExecutorService executor = Executors.newCachedThreadPool();
executor.execute(new Runnable() {
@Override
public void run() {
//do something
}
});
ExecutorService 提供了两种提交任务的方法：
-
execute()：提交不需要返回值的任务
-
submit()：提交需要返回值的任务
void execute(Runnable command);
execute() 的参数是一个 Runnable，也没有返回值。因此提交后无法判断该任务是否被线程池执行成功。
ExecutorService executor = Executors.newCachedThreadPool();
executor.execute(new Runnable() {
@Override
public void run() {
//do something
}
});
[外链图片转存中…(img-H58RqHcH-1635264788801)]
