一、四个线程池的的使用:
前期准备:模拟一个多线程的环境
public class X1 {
/**
* 创建线程模拟实际多线程情况
*/
public static Runnable newAndGetThread(final int n){
return new Runnable() {
@Override
public void run() {
try {
System.out.println("线程"+n+"开始");
Thread.sleep(1000);
System.out.println("线程"+n+"休眠结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程"+n+"结束");
}
};
}
}
第一种:使用newFixedThreadPool
/**
* 使用newFixedThreadPool
* 一下子将线程放进newFixedThreadPool线程池,
* 放的数量就是newFixedThreadPool的参数
* 一个线程结束,再放进去新的一个线程
*/
public void test(){
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
//execute方法会将线程池中的线程执行
executorService.execute(X1.newAndGetThread(i));
}
executorService.shutdown();
}
这个方法会发生OOM,为什么呢?
因为他的方法是这样定义的:
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
可以看到 new LinkedBlockingQueue() 这个参数,Linked代表这是一个链式队列,没有指定容量,所以这是一个无界队列,当大量任务堆积在这个队列,就可能发生OOM
第二种:使用newCachedThreadPool
/**
* 使用newCachedThreadPool
* 线程一波执行,然后这个池子会在60秒后自动释放资源,
* 不用 executorService.shutdown();去释放资源
*/
public void test(){
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
//execute方法会将线程池中的线程执行
executorService.execute(X1.newAndGetThread(i));
}
}
}
这个也可能发生OOM,为什么呢?
还是看一下源码:
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
这里可以看到任务队列虽然用了new SynchronousQueue(),但是我们注意到最大线程数用了 Integer.MAX_VALUE。这相当于代表线程数可以无线创建,你要不OOM,谁OOM?
第三种:使用newSingleThreadExecutor
**
* 使用newSingleThreadExecutor
* 线程会一个一个的执行,需要最后时候释放资源
*/
public void test(){
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
//execute方法会将线程池中的线程执行
executorService.execute(X1.newAndGetThread(i));
}
executorService.shutdown();
}
第四种:使用newScheduledThreadPool
/**
* 使用newScheduledThreadPool
* 周期性的开始线程池的处理
*/
public void test(){
ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
ses.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程开始");
Thread.sleep(1000);
System.out.println("线程休眠结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},0,2, TimeUnit.MICROSECONDS);
}
上面讲完了自带的四种线程池的创建,但是很显然,各有优劣,那么我们只能创建自定义的线程池了。
二、自定义线程池:
自己创建线程池,需要注意什么呢?
首先是线程数,你的是8核的CPU,那么你的核心线程数就可以是8+1,为什么是8呢,这样可以让你的8个CPU都不闲着,那为什么+1呢,因为万一有一个线程忽然终止了,那么这个+1的线程就可以立马替换上,绝不让CPU闲着。实际情况下,你设置8*2也是没问题的。
有种情况特殊:大家都知道访问资源比CPU更消耗时间,那么如果你的线程们都是在访问资源,比如文件操作或者数据库访问,那么一个线程,卡住的不是CPU的处理效率,而是资源访问的时间,这时候你的线程数可以设置的大一些。
代码:
public void test() {
/**
* 参数解释(按顺序):
* 核心线程数(可以执行的)
* 最大线程数
* 线程数多于核心线程数,某线程空闲时间超过这个参数的时间,这个线程会被回收
* 上面参数的单位
* 待处理的线程队列
* 拒绝策略
*/
ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
7,
0L,
TimeUnit.MICROSECONDS,
new LinkedBlockingDeque<Runnable>(1024),
new ThreadPoolExecutor.AbortPolicy());
//模拟1000个线程
for (int i = 0; i < 1000; i++) {
executor.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程开始");
Thread.sleep(1000);
System.out.println("当前线程名:"+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
try {
//下面两行一起使用,优雅的关闭线程池
executor.shutdown();
executor.awaitTermination(1000L,TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程池中任务全部结束");
}
上面的ThreadPoolExecutor executor = new ThreadPoolExecutor(…)就是创建线程池,下面的都是在模拟线程池的使用。
三、线程池的部分源码分析:
打开ThreadPoolExecutor的源码:
开头有这样一段注释:
* The runState provides the main lifecycle control, taking on values:
*
* RUNNING: Accept new tasks and process queued tasks
* SHUTDOWN: Don't accept new tasks, but process queued tasks
* STOP: Don't accept new tasks, don't process queued tasks,
* and interrupt in-progress tasks
* TIDYING: All tasks have terminated, workerCount is zero,
* the thread transitioning to state TIDYING
* will run the terminated() hook method
* TERMINATED: terminated() has completed
翻译过来就是:
线程池运行时有这样几个状态,如下所示:
RUNNING状态:接收新任务并处理排队的任务
SHUTDOWN状态:不接收新任务,但是处理池子中的任务
STOP状态:不接收新的任务,不处理池子中的任务
TIDYING状态:所有的任务都终止了
TERMINATED状态:池子结束了该释放了。
这个会对应下面代码中五个状态的声明:
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
看到这里我们心里大致有数了,线程池大概有这几种状态:
开始的时候是RUNNING,这个时候代表线程池开始工作了;
然后我们用了shutdown方法,线程池变成了SHUTDOWN状态,这个状态代表,我的线程池不能再进来新任务了,但是池子里的任务还是要执行完。
但是有时我们想立刻中止池子以及池子的任务,就会用shutdownNow方法,这个时候就会进入STOP状态,这个状态代表不接收新的任务,不处理池子中的任务,直接啥也不管,完全撂挑子;
一般来说,先进入SHUTDOWN状态,等池子里任务执行完,进入STOP状态;
当池子里没任务了,会进入TIDYING状态,这个状态没啥用,但是从SHUTDOWN或者STOP状态进入这个状态时,会调用线程池的一个生命周期钩子函数,就是terminated,这个函数可以被处理,做一些特定的业务;
最后就是terminated执行完后,会进入TERMINATED状态,线程池毁灭释放资源。
上面状态讲完,我们看到上面代码中有个“优雅关闭线程池”的两句代码:
executor.shutdown();
executor.awaitTermination(1000L,Timnit.SECONDS);
这里很多人会疑问,直接用shutdown()不好吗?
其实不是这样的,我们看一下shutdown()的源码:
有这样一段注释:
This method does not wait for previously submitted tasks to
* complete execution. Use {@link #awaitTermination awaitTermination}
* to do that.
这是啥意思呢?
就是说:这个方法执行后,不会等待池子里的线程执行完。
举个例子:
你在餐厅吃饭,忽然餐馆歇业了,阿姨要收拾餐桌了,但是你还没吃完。
这个情境下,shutdown()就是餐馆歇业,阿姨不会等你吃完再收拾餐桌,她就是要直接收拾餐桌。
但是你执行一下awaitTermination这个方法,阿姨就会等你吃完再收拾餐桌。
这样的好处是啥呢?
就是你的池子外还有线程等着执行,但是呢,一旦只用了shutdown()方法,就会让池子里的线程自行执行,我不管了,但是池子外的线程也可以执行了,就可能发生池子外的线程比池子里的线程先执行,从而导致某些数据出错,造成程序出现问题,这个问题是很难排查的。
所以还是用一下awaitTermination方法吧,告诉阿姨等一下,等我“吃完”,你再“收拾”。