Java四种线程池newCachedThreadPool,newFixedThreadPo。
。。
1、new Thread的弊端
执⾏⼀个异步任务你还只是如下new Thread吗？
Java
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. 提供定时执⾏、定期执⾏、单线程、并发数控制等功能。
2、Java 线程池
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建⼀个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若⽆可回收，则新建线程。newFixedThreadPool 创建⼀个定长线程池，可控制线程最⼤并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建⼀个周期线程池，⽀持定时及周期性任务执⾏。
newSingleThreadExecutor 创建⼀个单线程化的线程池，它只会⽤唯⼀的⼯作线程来执⾏任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执⾏。
(1). newCachedThreadPool
创建⼀个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若⽆可回收，则新建线程。⽰例代码如下：
Java
ExecutorService cachedThreadPool = wCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
@Override
public void run() {
System.out.println(index);
}
});
}
线程池为⽆限⼤，当执⾏第⼆个任务时第⼀个任务已经完成，会复⽤执⾏第⼀个任务的线程，⽽不⽤每次新建线程。
(2). newFixedThreadPool
创建⼀个定长线程池，可控制线程最⼤并发数，超出的线程会在队列中等待。⽰例代码如下：
Java
ExecutorService fixedThreadPool = wFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
因为线程池⼤⼩为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的⼤⼩最好根据系统资源进⾏设置。如Runtime().availableProcessors()。可参考。
(3) newScheduledThreadPool
创建⼀个周期线程池，⽀持定时及周期性任务执⾏。延迟执⾏⽰例代码如下：
Java
ScheduledExecutorService scheduledThreadPool = wScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
表⽰延迟3秒执⾏。
定期执⾏⽰例代码如下：
Java
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);
表⽰延迟1秒后每3秒执⾏⼀次。
ScheduledExecutorService⽐Timer更安全，功能更强⼤，后⾯会有⼀篇单独进⾏对⽐。
(4)、newSingleThreadExecutor
创建⼀个单线程化的线程池，它只会⽤唯⼀的⼯作线程来执⾏任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执⾏。⽰例代码如下：Java
ExecutorService singleThreadExecutor = wSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
结果依次输出，相当于顺序执⾏各个任务。
现⾏⼤多数GUI程序都是单线程的。Android中单线程可⽤于，⽂件操作，应⽤批量安装，应⽤批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。
线程池的作⽤：
线程池作⽤就是限制系统中执⾏线程的数量。
java线程池创建的四种根据系统的环境情况，可以⾃动或⼿动设置线程数量，达到运⾏的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不⾼。⽤线程池控制线程数量，其他线程排队等候。⼀个任务执⾏完毕，再从队列的中取最前⾯的任务开始执⾏。若队列中没有等待进程，线程池的这⼀资源处于等待。当⼀个新任务需要运⾏时，如果线程池中有等待的⼯作线程，就可以开始运⾏了；否则进⼊等待队列。
为什么要⽤线程池:
1.减少了创建和销毁线程的次数，每个⼯作线程都可以被重复利⽤，可执⾏多个任务。
2.可以根据系统的承受能⼒，调整线程池中⼯作线线程的数⽬，防⽌因为消耗过多的内存，⽽把服务器累趴下(每个线程需要⼤约1MB内存，线程开的越多，消耗的内存也就越⼤，最后死机)。
Java⾥⾯线程池的顶级接⼝是Executor，但是严格意义上讲Executor并不是⼀个线程池，⽽只是⼀个执⾏线程的⼯具。真正的线程池接⼝是ExecutorService。
⽐较重要的⼏个类：
ExecutorService真正的线程池接⼝。
ScheduledExecutorService能和Timer/TimerTask类似，解决那些需要任务重复执⾏
的问题。
ThreadPoolExecutor ExecutorService的默认实现。
ScheduledThreadPoolExecutor继承ThreadPoolExecutor的ScheduledExecutorService
接⼝实现，周期性任务调度的类实现。
要配置⼀个线程池是⽐较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类⾥⾯提供了⼀些静态⼯⼚，⽣成⼀些常⽤的线程池。
1. newSingleThreadExecutor
创建⼀个单线程的线程池。这个线程池只有⼀个线程在⼯作，也就是相当于单线程串⾏执⾏所有任务。如果这个唯⼀的线程因为异常结束，那么会有⼀个新的线程来替代它。此线程池保证所有任务的执⾏顺序按照任务的提交顺序执⾏。
创建固定⼤⼩的线程池。每次提交⼀个任务就创建⼀个线程，直到线程达到线程池的最⼤⼤⼩。线程
池的⼤⼩⼀旦达到最⼤值就会保持不变，如果某个线程因为执⾏异常⽽结束，那么线程池会补充⼀个新线程。
3. newCachedThreadPool
创建⼀个可缓存的线程池。如果线程池的⼤⼩超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执⾏任务）的线程，当任务数增加时，此线程池⼜可以智能的添加新线程来处理任务。此线程池不会对线程池⼤⼩做限制，线程池⼤⼩完全依赖于操作系统（或者说JVM）能够创建的最⼤线程⼤⼩。
创建⼀个⼤⼩⽆限的线程池。此线程池⽀持定时以及周期性执⾏任务的需求。
⽆论创建那种线程池必须要调⽤ThreadPoolExecutor
线程池类为 urrent.ThreadPoolExecutor，常⽤构造⽅法为：
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue workQueue,
RejectedExecutionHandler handler)
corePoolSize：线程池维护线程的最少数量
maximumPoolSize：线程池维护线程的最⼤数量
keepAliveTime：线程池维护线程所允许的空闲时间
unit：线程池维护线程所允许的空闲时间的单位
workQueue：线程池所使⽤的缓冲队列
handler：线程池对拒绝任务的处理策略
⼀个任务通过 execute(Runnable)⽅法被添加到线程池，任务就是⼀个 Runnable类型的对象，任务的执⾏⽅法就是 Runnable类型对象的run()⽅法。
当⼀个任务通过execute(Runnable)⽅法欲添加到线程池时：
如果此时线程池中的数量⼩于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放⼊缓冲队列。
如果此时线程池中的数量⼤于corePoolSize，缓冲队列workQueue满，并且线程池中的数量⼩于maximumPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量⼤于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。
也就是：处理任务的优先级为：
核⼼线程corePoolSize、任务队列workQueue、最⼤线程maximumPoolSize，如果三者都满了，使⽤handler处理被拒绝的任务。
当线程池中的线程数量⼤于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终⽌。这样，线程池可以动态的调整池中的线程数。
unit可选的参数为urrent.TimeUnit中的⼏个静态属性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
workQueue我常⽤的是：urrent.ArrayBlockingQueue
handler有四个选择：
ThreadPoolExecutor.AbortPolicy()
抛出urrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务，他会⾃动重复调⽤execute()⽅法
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务
当然也可以根据应⽤场景实现RejectedExecutionHandler接⼝，⾃定义饱和策略，如记录⽇志或持久化存储不能处理的任务。
Executor 可以创建 3 种类型的 ThreadPoolExecutor 线程池：
1. FixedThreadPool
创建固定长度的线程池，每次提交任务创建⼀个线程，直到达到线程池的最⼤数量，线程池的⼤⼩不再变化。
这个线程池可以创建固定线程数的线程池。特点就是可以重⽤固定数量线程的线程池。它的构造源码如下：
1 2 3 4 5public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
FixedThreadPool的corePoolSize和maxiumPoolSize都被设置为创建FixedThreadPool时指定的参数nThreads。
0L则表⽰当线程池中的线程数量操作核⼼线程的数量时，多余的线程将被⽴即停⽌
最后⼀个参数表⽰FixedThreadPool使⽤了⽆界队列LinkedBlockingQueue作为线程池的做⼯队列，由于是⽆界的，当线程池的线程数达到corePoolSize后，新任务将在⽆界队列中等待，因此线程池的线程数量不会超过corePoolSize，同时maxiumPoolSize也就变成了⼀个⽆效的参数，并且运⾏中的线程池并不会拒绝任务。
FixedThreadPool运⾏图如下
执⾏过程如下：
1.如果当前⼯作中的线程数量少于corePool的数量，就创建新的线程来执⾏任务。
2.当线程池的⼯作中的线程数量达到了corePool，则将任务加⼊LinkedBlockingQueue。
3.线程执⾏完1中的任务后会从队列中去任务。
注意LinkedBlockingQueue是⽆界队列，所以可以⼀直添加新任务到线程池。
2. SingleThreadExecutor 
SingleThreadExecutor是使⽤单个worker线程的Executor。特点是使⽤单个⼯作线程执⾏任务。它的构造源码如下：
1 2 3 4 5 6public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>())); }
SingleThreadExecutor的corePoolSize和maxiumPoolSize都被设置1。其他参数均与FixedThreadPool相同，其运⾏图如下：

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。