转载请注明出处:http://blog.csdn.net/u013038616/article/details/50732830
1、线程池的优点:
a、重用线程池中的线程,避免线程创建与销毁带来的开销。
b、有效的控制线程池的最大并发数量,避免大量线程之间抢夺资源而造成的阻塞现象。
2、ThreadPoolExecutor类
线程池的实现类,他提供正真的线程池的功能。如下是该类的继承关系,以及完整类签名和主要的构造函数:
继承关系:
java.lang.Object
继承者 java.util.concurrent.AbstractExecutorService
继承者 java.util.concurrent.ThreadPoolExecutor
完成类签名:
public class ThreadPoolExecutor extends AbstractExecutorService
主要的构造方法:
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
通过构造函数不同的参数配置可以构造不同的线程池对象。各项参数介绍如下(jdk的帮助文档是最好的学习工具):
corePoolSize和maximumPoolSize:
ThreadPoolExecutor 将根据 corePoolSize 和 maximumPoolSize设置的边界自动调整池大小。当新任务在方法 execute(java.lang.Runnable) 中提交时,如果运行的线程少于 corePoolSize,则创建新线程来处理请求,即使其他辅助线程是空闲的。如果运行的线程多于corePoolSize 而少于 maximumPoolSize,则仅当队列满时才创建新线程。如果设置的 corePoolSize 和 maximumPoolSize 相同,则创建了固定大小的线程池。如果将 maximumPoolSize 设置为基本的无界值(如Integer.MAX_VALUE),则允许池适应任意数量的并发任务。在大多数情况下,核心和最大池大小仅基于构造来设置,不过也可以使用 setCorePoolSize(int) 和setMaximumPoolSize(int) 进行动态更改。
keepAliveTime:
如果池中当前有多于 corePoolSize 的线程,则这些多出的线程在空闲时间超过 keepAliveTime 时将会终止。这提供了当池处于非活动状态时减少资源消耗的方法。如果池后来变得更为活动,则可以创建新的线程。也可以使用方法setKeepAliveTime(long, java.util.concurrent.TimeUnit) 动态地更改此参数。使用Long.MAX_VALUE TimeUnit.NANOSECONDS 的值在关闭前有效地从以前的终止状态禁用空闲线程。默认情况下,保持活动策略只在有多于 corePoolSizeThreads 的线程时应用。但是只要keepAliveTime 值非 0,allowCoreThreadTimeOut(boolean) 方法也可将此超时策略应用于核心线程。
unit:指定keepAliveTime的事件单位。通过TimeUnit枚举选择,包括分,秒,毫秒。
workQueue:
所有 BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互:
i、如果运行的线程少于 corePoolSize,则 Executor 始终首选添加新的线程,而不进行排队。ii、如果运行的线程等于或多于 corePoolSize,则 Executor 始终首选将请求加入队列,而不添加新的线程。iii、如果无法将请求加入队列,且线程数小于maximumPoolSize,则创建新的线程,否则任务将被拒绝。
排队有三种通用策略:
a、直接提交。工作队列的默认选项是 SynchronousQueue,它将任务直接提交给线程而不保持它们。在此,如果不存在可用于立即运行任务的线程,则试图把任务加入队列将失败,因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。
b、无界队列。使用无界队列(例如,不具有预定义容量的 LinkedBlockingQueue)将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样,创建的线程就不会超过 corePoolSize。(因此,maximumPoolSize 的值也就无效了。)当每个任务完全独立于其他任务,即任务执行互不影响时,适合于使用无界队列;例如,在 Web 页服务器中。这种排队可用于处理瞬态突发请求,当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。
c、有界队列。当使用有限的 maximumPoolSizes 时,有界队列(如 ArrayBlockingQueue)有助于防止资源耗尽,但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷:使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销,但是可能导致人工降低吞吐量。如果任务频繁阻塞(例如,如果它们是 I/O 边界),则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小,CPU 使用率较高,但是可能遇到不可接受的调度开销,这样也会降低吞吐量。
被拒绝的任务
当 Executor 已经关闭,并且 Executor 将有限边界用于最大线程和工作队列容量,且已经饱和时,在方法 execute(java.lang.Runnable) 中提交的新任务将被拒绝。在以上两种情况下,execute 方法都将调用其 RejectedExecutionHandler 的RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。
下面提供了四种预定义的处理程序策略:
a、在默认的 ThreadPoolExecutor.AbortPolicy 中,处理程序遭到拒绝将抛出运行时 RejectedExecutionException。b、在 ThreadPoolExecutor.CallerRunsPolicy 中,线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制,能够减缓新任务的提交速度。c、在 ThreadPoolExecutor.DiscardPolicy 中,不能执行的任务将被删除。d、在 ThreadPoolExecutor.DiscardOldestPolicy 中,如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,然后重试执行程序(如果再次失败,则重复此过程)。
注意:定义和使用其他种类的 RejectedExecutionHandler 类也是可能的,但这样做需要非常小心,尤其是当策略仅用于特定容量或排队策略时。
threadFactory:
使用 ThreadFactory 创建新线程。如果没有另外说明,则在同一个 ThreadGroup 中一律使用Executors.defaultThreadFactory() 创建线程,
并且这些线程具有相同的NORM_PRIORITY 优先级和非守护进程状态。通过提供不同的 ThreadFactory,可以改变线程的名称、线程组、优先级、守护
进程状态,等等。如果从 newThread 返回 null 时 ThreadFactory 未能创建线程,则执行程序将继续运行,但不能执行任何任务。
/**
* The default thread factory
*/
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}
handler:
当没有任务可以执行时,调用handler通知调用者。默认抛出RejectedExectionException。
可以根据不同的需要配置ThreadPoolExecutor类来得到不同功能的线程池对象。
一个任务通过 execute(Runnable)方法被添加到线程池,任务就是一个 Runnable类型的对象,任务的执行方法就是 Runnable类型对象的run()方法。
3、Executors工具类中常用的线程池:
通过Executors工具类的静态方法可以构建出4中不同的线程池对象:
a、CachedThreadPool(无界线程池,可以进行自动线程回收)
Executors.newCachedThreadPool()
特点:
i、如果线程池中的线程都处于互动状态的话,它会新建线程来执行该任务,否则从用空闲线程。
ii、如果空闲线程60秒没有被利用则被回收。
iii、适合执行大量耗时短的任务。
b、FixedThreadPool(固定大小线程池)
Executors.newFixedThreadPool(nThreads)
特点:
i、线程池中线程数固定,当前线程空闲也不会被回收,除非关闭线程池。
ii、所有线程处于活跃状态则新任务会被阻塞。
c、ScheduledThreadPool (可延时执行的线程池,采用延时队列实现的)
d、SingleThreadExecutor (单个后台线程)Executors.newScheduledThreadPool(nThreads)
特点: i、核心线程数固定,非核心线程数没有限制,当核心线程闲置时也会被回收。
ii、可以执行定时任务和固定周期的任务。
Executors.newSingleThreadExecutor()
特点: i、只有一个核心线程。
ii、所有任务将按添加顺序在同一个线程中执行。
iii、统一外部的任务到一个线程中,使得任务之间不需要处理线程同步的问题。
4、使用线程池对象。
a、创建线程池对象,可以通过上述方法。
b、创建任务Runnable对象。
c、使用线程池对象的execute(Runnable r)方法添加该任务。
Runnable command = new Runnable() {
@Override
public void run() {
SystemClock.sleep(2000);
}
};
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
fixedThreadPool.execute(command);
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
cachedThreadPool.execute(command);
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
// 2000ms后执行command
scheduledThreadPool.schedule(command, 2000, TimeUnit.MILLISECONDS);
// 延迟10ms后,每隔1000ms执行一次command
scheduledThreadPool.scheduleAtFixedRate(command, 10, 1000, TimeUnit.MILLISECONDS);
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
singleThreadExecutor.execute(command);