回忆一下java的线程池的知识。
一个app中可能因为需要会开很多个线程去执行任务,也许为图省事直接new 一个thread,其实它同时会带来很大的弊端,如内存过度消耗,创建和消耗对象费时费CPU资源等
线程池可以看做装载线程的容器,当打开一个app时,在application中可以声明并创建一个线程池来管理整个app的线程,因为一个应用程序最多只能有一个线程池。
那么为什么要创建线程池呢?
1.提升性能。创建和消耗对象费时费CPU资源,引入线程池可以减少了创建和销毁线程所需的时间,从而提高效率
2.防止内存过度消耗。控制活动线程的数量,防止并发线程过多。
所有线程都应该装入线程池么?答案是:并不是
那么什么样的线程应该单独的new thread来完成呢?
1.任务需要很长时间
2.线程需要被指定优先级
3.需要对线程进行操作(wait)
所以ThreadPool应该适合于一些任务所需时间短,相互不影响的线程。
java通过Executors提供四种线程池,分别为:
newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。(我习惯用这种)
newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
这里提供一个线程池的工具类,可以去操作学习。
public class ThreadPoolManger {
public enum Type {
SingleThread,
FixedThread,
CachedThread,
ScheduledSingleThread
}
private static final int DEFAULT_THREADS = 3;
private ExecutorService executorService = null;
private Type nowType;
public ThreadPoolManger(Type type) {
nowType = type;
switch (type) {
case SingleThread:
executorService = Executors.newSingleThreadExecutor();
break;
case FixedThread:
executorService = Executors.newFixedThreadPool(DEFAULT_THREADS);
break;
case CachedThread:
executorService = Executors.newCachedThreadPool();
break;
case ScheduledSingleThread:
executorService = Executors.newSingleThreadScheduledExecutor();
break;
}
}
/**
* 延迟一定时间后开始执行Runnable,效果同{@link new Handler().postDelay}
*
* @param runnable 执行的任务
* @param initialDelay 延迟时间
*/
public void schedule(Runnable runnable, long initialDelay) {
((ScheduledExecutorService) executorService).schedule(runnable, initialDelay, TimeUnit.MILLISECONDS);
}
/**
* 延迟一定时间后,开始执行Runnable,完成后延迟一定时间再重新执行Runnable
*
* @param runnable 执行的任务
* @param initialDelay 初始延迟时间
* @param delay 上次完成后至下次开始延迟的时间
*/
public void scheduleWithFixedDelay(Runnable runnable, long initialDelay, long delay) {
((ScheduledExecutorService) executorService).scheduleWithFixedDelay(runnable, initialDelay, delay, TimeUnit.MILLISECONDS);
}
/**
* 每隔固定时间开始执行Runnable,固定频率
*
* @param runnable 执行的任务
* @param initialDelay 初始延迟时间
* @param period 每隔period时间再次执行Runnable任务
*/
public void scheduleWithFixedRate(Runnable runnable, long initialDelay, long period) {
((ScheduledExecutorService) executorService).scheduleAtFixedRate(runnable, initialDelay, period, TimeUnit.MILLISECONDS);
}
public void execute(Runnable runnable) {
executorService.execute(runnable);
}
public void execute(List<Runnable> runnables) {
for (Runnable runnable : runnables) {
executorService.execute(runnable);
}
}
public Future<?> submit(Runnable runnable) {
return executorService.submit(runnable);
}
public boolean isShutDown() {
return executorService.isShutdown();
}
public void shutDown() {
executorService.shutdown();
}
public void shutDownNow() {
executorService.shutdownNow();
executorService = null;
}
}
那么