1、new Thread的弊端
执行一个异步任务你还只是如下new Thread吗？
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
}).start();
那你就out太多了，new Thread的弊端如下：
a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
1.CachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
public class ThreadRunner implements Runnable{
private int num;
private int timeout;
public ThreadRunner(int num,int timeout){
this.num = num;
this.timeout = timeout;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":运行中,"+num);
try {
TimeUnit.SECONDS.sleep(timeout);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; public class CacheThreadPoolMain {
public static void main(String[] args) {
ExecutorService pool = Executors.newCachedThreadPool();
for(int i = 1;i<21;i++){
pool.submit(new ThreadRunner(i,0));
}
pool.shutdown();
}
}
结果：
pool-1-thread-1:运行中,1
pool-1-thread-5:运行中,5
pool-1-thread-2:运行中,2
pool-1-thread-7:运行中,7
pool-1-thread-4:运行中,4
pool-1-thread-9:运行中,9
pool-1-thread-3:运行中,3
pool-1-thread-10:运行中,10
pool-1-thread-8:运行中,8
pool-1-thread-6:运行中,6
pool-1-thread-12:运行中,12
pool-1-thread-11:运行中,11
pool-1-thread-13:运行中,13
pool-1-thread-9:运行中,14
pool-1-thread-10:运行中,20
pool-1-thread-13:运行中,15
pool-1-thread-8:运行中,19
pool-1-thread-11:运行中,16
pool-1-thread-6:运行中,18
pool-1-thread-12:运行中,17
总结
- 池中线程时随着处理数据增加而增加
- 线程数并不是一直增加，如果有新任务需要执行时，首先查询池中是否有空闲线程并且还为到空闲截止时间，如果有，则使用空闲线程，如果没有，则创建新线程并放入池中。
- 用于执行一些生存期很短的异步型任务。不适用于IO等长延时操作，因为这可能会创建大量线程，导致系统崩溃。
- 使用SynchronousQueue作为阻塞队列，如果有新任务进入队列，必须队列中数据被其他线程处理，否则会等待。
2.FixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
import java.util.concurrent.TimeUnit;
public class ThreadRunner implements Runnable{
private int num;
private int timeout;
public ThreadRunner(int num,int timeout){
this.num = num;
this.timeout = timeout;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":运行中,"+num);
try {
TimeUnit.SECONDS.sleep(timeout);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; public class FixedThreadPoolMain {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(3);//有一个固定大小的线程池 for(int i = 1;i<21;i++){
pool.submit(new ThreadRunner(i,2));
} pool.shutdown();
}
}
总结：
- 池中线程数量固定，不会发生变化
- 使用*的LinkedBlockingQueue，要综合考虑生成与消费能力，生成过剩，可能导致堆内存溢出。
- 适用一些很稳定很固定的正规并发线程，多用于服务器
3.ScheduledExcutorPool
创建一个定长线程池，支持定时及周期性任务执行。
ScheduledThreadPool中常用的ScheduleAtFixedRate和ScheduleWithFixedDelay
* ScheduleAtFixedRate 每次执行时间为上一次任务开始起向后推一个时间间隔，
* 即每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2*period, …；
* ScheduleWithFixedDelay 每次执行时间为上一次任务结束起向后推一个时间间隔，
* 即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay
*
* ScheduleAtFixedRate 是基于固定时间间隔进行任务调度，
* ScheduleWithFixedDelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit; public class ThreadRunner implements Runnable{
private final SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss.SSS"); private int num;
private int timeout;
public ThreadRunner(int num,int timeout){
this.num = num;
this.timeout = timeout;
} @Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":当前时间："+format.format(new Date())+",运行中,"+num);
try {
TimeUnit.SECONDS.sleep(timeout);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit; public class ScheduledExcutorPoolMain {
public static void main(String[] args) {
ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);//线程池 // 从现在开始5秒钟之后，每隔10秒钟执行一次ThreadRunner
pool.scheduleAtFixedRate(new ThreadRunner(2,3), 5,10, TimeUnit.SECONDS); // 从现在开始5秒钟之后，每隔10秒钟执行一次job2
pool.scheduleWithFixedDelay(new ThreadRunner(3,3), 5, 10, TimeUnit.SECONDS); /**
* ScheduleAtFixedRate 每次执行时间为上一次任务开始起向后推一个时间间隔，
* 即每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2*period, …；
* ScheduleWithFixedDelay 每次执行时间为上一次任务结束起向后推一个时间间隔，
* 即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay
*
* ScheduleAtFixedRate 是基于固定时间间隔进行任务调度，
* ScheduleWithFixedDelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度
*/
}
}
总结：
- 线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
- 只有当调度任务来的时候,ScheduledExecutorService才会真正启动一个线程,其余时间ScheduledExecutorService都是出于轮询任务的状态
4.SingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照提交顺序被执行
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit; public class ThreadRunner implements Runnable{
private final SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss.SSS"); private int num;
private int timeout;
public ThreadRunner(int num,int timeout){
this.num = num;
this.timeout = timeout;
} @Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":当前时间："+format.format(new Date())+",运行中,"+num);
try {
TimeUnit.SECONDS.sleep(timeout);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; public class SingleThreadPool {
public static void main(String[] args) {
ExecutorService pool = Executors.newSingleThreadExecutor();
for(int i=1;i<21;i++){
pool.submit(new ThreadRunner(i,5));
}
pool.shutdown();
}
}
结果：
pool-1-thread-1:当前时间：15:53:35.883,运行中,1
pool-1-thread-1:当前时间：15:53:40.884,运行中,2
pool-1-thread-1:当前时间：15:53:45.884,运行中,3
pool-1-thread-1:当前时间：15:53:50.884,运行中,4
pool-1-thread-1:当前时间：15:53:55.884,运行中,5
pool-1-thread-1:当前时间：15:54:00.885,运行中,6
pool-1-thread-1:当前时间：15:54:05.885,运行中,7
pool-1-thread-1:当前时间：15:54:10.886,运行中,8
pool-1-thread-1:当前时间：15:54:15.886,运行中,9
pool-1-thread-1:当前时间：15:54:20.887,运行中,10
pool-1-thread-1:当前时间：15:54:25.887,运行中,11
pool-1-thread-1:当前时间：15:54:30.887,运行中,12
pool-1-thread-1:当前时间：15:54:35.888,运行中,13
pool-1-thread-1:当前时间：15:54:40.888,运行中,14
pool-1-thread-1:当前时间：15:54:45.888,运行中,15
pool-1-thread-1:当前时间：15:54:50.888,运行中,16
pool-1-thread-1:当前时间：15:54:55.889,运行中,17
pool-1-thread-1:当前时间：15:55:00.889,运行中,18
pool-1-thread-1:当前时间：15:55:05.889,运行中,19
pool-1-thread-1:当前时间：15:55:10.890,运行中,20
总结：
- 线程中只有一个线程在执行
- 适用于有明确执行顺序但是不影响主线程的任务，压入池中的任务会按照队列顺序执行。
- 使用*的LinkedBlockingQueue，要综合考虑生成与消费能力，生成过剩，可能导致堆内存溢出。
源码地址：https://github.com/qjm201000/concurrent_executorService.git