一、线程池的优点
说到线程池的优点就要先说一下不用线程池的坏处
- 在早些年开发都是直接new Thread()直接创建线程,倘若有N个异步就要创建N个线程,这会导致线程的频繁创建和销毁
- 线程不可控,每个线程都各自执行,内存资源竞争激烈,这可能会导致OOM
使用线程池的好处
- 不用频繁创建线程,可重用线程池中的线程,免去了频繁创建的性能开销
- 可控制线程的最大并发,超过一定数量的线程进入队列等待执行
二、线程池的使用
1:ThreadPoolExecutor 创建基本线程池
创建线程池,主要是利用ThreadPoolExecutor这个类,而这个类有几种构造方法,其中参数最多的一种构造方法如下:
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
...
}
corePoolSize: 该线程池中核心线程的数量。
注意:线程池中存在核心线程与非核心线程,核心线程一旦创建会一直执行任务或等待任务到来,而非核心线程只在任务队列塞满任务时去执行多出的任务,并且非核心线程在等待一段时间后将会被回收,这个时间作为参数可调配,见下面的keepAliveTime参数。
maximumPoolSize:该线程池中最大线程数量。(区别于corePoolSize)
keepAliveTime:从字面上就可以理解,是非核心线程空闲时要等待下一个任务到来的时间,当任务很多,每个任务执行时间很短的情况下调大该值有助于提高线程利用率。注意:当allowCoreThreadTimeOut属性设为true时,该属性也可用于核心线程。
unit:上面时间属性的单位
workQueue:任务队列,后面详述。
threadFactory:线程工厂,可用于设置线程名字等等,一般无须设置该参数。
设置好几个参数就可以创建一个基本的线程池,而之后的各种线程池都是在这种基本线程池的基础上延伸的。
下面贴个自己写的demo来熟悉具体的使用并且加深影响:
//创建基本线程池
final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3,5,1,TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(100));
设置一个按钮mThreadPoolExecute,并在点击事件中使用线程池
/**
* 基本线程池使用
*/
mThreadPoolExecute.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
for(int i = 0;i<30;i++){
final int finali = i;
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
Log.d("Thread", "run: "+finali);
Log.d("当前线程:",Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(runnable);
}
}
});
结果会每2s打印三个日志。
具体过程:
1.execute一个线程之后,如果线程池中的线程数未达到核心线程数,则会立马启用一个核心线程去执行。
2.execute一个线程之后,如果线程池中的线程数已经达到核心线程数,且workQueue未满,则将新线程放入workQueue中等待执行。
3.execute一个线程之后,如果线程池中的线程数已经达到核心线程数但未超过非核心线程数,且workQueue已满,则开启一个非核心线程来执行任务。
4.execute一个线程之后,如果线程池中的线程数已经超过非核心线程数,则拒绝执行该任务,采取饱和策略,并抛出RejectedExecutionException异常。
demo中设置的任务队列长度为100,所以不会开启额外的5-3=2个非核心线程,如果将任务队列设为25,则前三个任务被核心线程执行,剩下的30-3=27个任务进入队列会满,此时会开启2个非核心线程来执行剩下的两个任务。
//新开启了thread-4与thread-5执行剩下的超出队列的两个任务28和29
2019-03-28 15:54:07.879 22284-22618/com.example.threadpooltest D/Thread:: 1
2019-03-28 15:54:07.879 22284-22617/com.example.threadpooltest D/Thread:: 0
2019-03-28 15:54:07.879 22284-22617/com.example.threadpooltest D/当前线程:: pool-1-thread-1
2019-03-28 15:54:07.879 22284-22618/com.example.threadpooltest D/当前线程:: pool-1-thread-2
2019-03-28 15:54:07.880 22284-22619/com.example.threadpooltest D/Thread:: 2
2019-03-28 15:54:07.880 22284-22619/com.example.threadpooltest D/当前线程:: pool-1-thread-3
2019-03-28 15:54:07.881 22284-22620/com.example.threadpooltest D/Thread:: 28
2019-03-28 15:54:07.881 22284-22620/com.example.threadpooltest D/当前线程:: pool-1-thread-4
2019-03-28 15:54:07.881 22284-22621/com.example.threadpooltest D/Thread:: 29
2019-03-28 15:54:07.881 22284-22621/com.example.threadpooltest D/当前线程:: pool-1-thread-5
疑问:每个for循环里都有一个sleep(2000),为何会每隔2s打印三个任务?
原因:因为一开始的时候只是声明runnable对象并且重写run()方法,并没有运行,而后execute(runnable) 才会sleep,又因为一开始创建线程池的时候声明的核心线程数为3,所以会首先开启三个核心线程,然后执行各自的run方法,虽然有先后顺序,但这之间的间隔很短,所以2s后同时打印3个任务。
2:FixedThreadPool (可重用固定线程数)
Executors类中的创建方法:
FixedThreadPool创建
特点:参数为核心线程数,只有核心线程,无非核心线程,并且阻塞队列无界。
demo代码:
创建:
//创建fixed线程池
final ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
使用:
/**
* fixed线程池
*/
mFixedPoolThread.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
for(int i = 0;i<30;i++){
final int finali = i;
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
Log.d("Thread", "run: "+finali);
Log.d("当前线程:",Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
fixedThreadPool.execute(runnable);
}
}
});
结果为每2s打印5次任务,跟上面的基础线程池类似。
3:CachedThreadPool (按需创建)
Executors类中的创建方法:
CachedThreadPool创建
特点:没有核心线程,只有非核心线程,并且每个非核心线程空闲等待的时间为60s,采用SynchronousQueue队列。
demo代码:
创建:
//创建Cached线程池
final ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
使用:
/**
* cached线程池
*/
mCachedPoolThread.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
for(int i = 0;i<30;i++){
final int finali = i;
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
Log.d("Thread", "run: "+finali);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
cachedThreadPool.execute(runnable);
}
}
});
结果:过2s后直接打印30个任务
结果分析:
- 因为没有核心线程,其他全为非核心线程,SynchronousQueue是不存储元素的,每次插入操作必须伴随一个移除操作,一个移除操作也要伴随一个插入操作。
- 当一个任务执行时,先用SynchronousQueue的offer提交任务,如果线程池中有线程空闲,则调用SynchronousQueue的poll方法来移除任务并交给线程处理;如果没有线程空闲,则开启一个新的非核心线程来处理任务。
- 由于maximumPoolSize是无界的,所以如果线程处理任务速度小于提交任务的速度,则会不断地创建新的线程,这时需要注意不要过度创建,应采取措施调整双方速度,不然线程创建太多会影响性能。
- 从其特点可以看出,CachedThreadPool适用于有大量需要立即执行的耗时少的任务的情况。
4:SingleThreadPool(单个核线的fixed)
创建方法:
SingleThreadPool创建
创建:
//创建Single线程池
final ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
使用:
/**
* single线程池
*/
mSinglePoolExecute.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
for(int i = 0;i<30;i++){
final int finali = i;x
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
Log.d("Thread", "run: "+finali);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
singleThreadExecutor.execute(runnable);
}
}
});
结果:每2s打印一个任务,由于只有一个核心线程,当被占用时,其他的任务需要进入队列等待。
5:ScheduledThreadPool(定时延时执行)
创建方法:
ScheduledThreadPool创建1
ScheduledThreadPool创建2
创建:
//创建Scheduled线程池
final ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
使用:
/**
* scheduled线程池
*/
mScheduledTheadPool.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Runnable runnable = new Runnable() {
@Override
public void run() {
Log.d("Thread", "This task is delayed to execute");
}
};
scheduledThreadPool.schedule(runnable,10,TimeUnit.SECONDS);//延迟启动任务
//延迟5s后启动,每1s执行一次 scheduledThreadPool.scheduleAtFixedRate(runnable,5,1,TimeUnit.SECONDS);
//启动后第一次延迟5s执行,后面延迟1s执行 scheduledThreadPool.scheduleWithFixedDelay(runnable,5,1,TimeUnit.SECONDS);
}
});
结果如代码所述。
public class ThreadPool {/*** 线程池大小*/static int corePoolSize = 10;/*** 线程池最大数量*/static int maxmunPoolSize = 50;/*** 线程活动保持时间*/static int keepAliveTime = 5;/*** 任务队列*/static ArrayBlockingQueue workQueue = new ArrayBlockingQueue(10);private static ThreadPool threadPool;public static synchronized ThreadPool getInstance() {if (threadPool == null) {threadPool = new ThreadPool();}return threadPool;}public void exe(Runnable runnable) {ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize,maxmunPoolSize,keepAliveTime,TimeUnit.SECONDS,workQueue);threadPoolExecutor.execute(runnable);} }