java ThreadPool线程池的使用,线程池工具类用法说明
实际上java已经提供线程池的实现ExecutorService。
为了更方便的使用和管理。这里提供一个线程池工具类，方便大家的使用。
直接看看代码：
使用
publicstaticvoidmain(String[]args)
{
//实例化一个固定数目的线程池。具体参考类的构造方法
ThreadPoolthreadPool=newThreadPool(ThreadPool.FixedThread,5);
//线程池执行线程
threadPool.execute(newRunnable(){
@Override
publicvoidrun(){
}
});
}
工具类：
packagecom.rbl.ncf.common.plugin.threadpool;
importjava.lang.annotation.Retention;
importjava.lang.annotation.RetentionPolicy;
importjava.util.Collection;
importjava.util.List;
importjava.util.concurrent.Callable;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Future;
importjava.util.concurrent.ScheduledExecutorService;
importjava.util.concurrent.ScheduledFuture;
importjava.util.concurrent.TimeUnit;
importjava.util.concurrent.TimeoutException;
/**
*线程池工具类
*/
publicclassThreadPool{
publicstaticfinalintFixedThread=0;
publicstaticfinalintCachedThread=1;
publicstaticfinalintSingleThread=2;
@Retention(RetentionPolicy.SOURCE)
public@interfaceType{
}
privateExecutorServiceexec;
privateScheduledExecutorServicescheduleExec;
privateThreadPool(){
thrownewUnsupportedOperationException("ucan'tinstantiateme...");
}
/**
*ThreadPoolUtils构造函数
*
*@paramtype线程池类型
*@paramcorePoolSize只对Fixed和Scheduled线程池起效
*/
publicThreadPool(finalinttype,finalintcorePoolSize){
//构造有定时功能的线程池
//ThreadPoolExecutor(corePoolSize,Integer.MAX_VALUE,10L,TimeUnit.MILLISECONDS,new
//BlockingQueue)
scheduleExec=Executors.newScheduledThreadPool(corePoolSize);
switch(type){
caseFixedThread:
//构造一个固定线程数目的线程池
//ThreadPoolExecutor(corePoolSize,corePoolSize,0L,TimeUnit.MILLISECONDS,new
//LinkedBlockingQueue());
exec=Executors.newFixedThreadPool(corePoolSize);
break;
caseSingleThread:
//构造一个只支持一个线程的线程池,相当于newFixedThreadPool(1)
//ThreadPoolExecutor(1,1,0L,TimeUnit.MILLISECONDS,new
//LinkedBlockingQueue())
exec=Executors.newSingleThreadExecutor();
break;
caseCachedThread:
//构造一个缓冲功能的线程池
//ThreadPoolExecutor(0,Integer.MAX_VALUE,60L,TimeUnit.SECONDS,new
//SynchronousQueue());
exec=Executors.newCachedThreadPool();
break;
}
}
/**
*在未来某个时间执行给定的命令该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由Executor实现决定。
*
*@paramcommand命令
*/
publicvoidexecute(finalRunnablecommand){
exec.execute(command);
}
/**
*在未来某个时间执行给定的命令链表该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由Executor实现决定。
*
*@paramcommands命令链表
*/
publicvoidexecute(finalListcommands){
for(Runnablecommand:commands){
exec.execute(command);
}
}
/**
*待以前提交的任务执行完毕后关闭线程池启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有作用。
*/
publicvoidshutDown(){
exec.shutdown();
}
/**
*试图停止所有正在执行的活动任务试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。
*无法保证能够停止正在处理的活动执行任务，但是会尽力尝试。
*
*@return等待执行的任务的列表
*/
publicListshutDownNow(){
returnexec.shutdownNow();
}
/**
*判断线程池是否已关闭
*
*@return{@codetrue}:是
{@codefalse}:否
*/
publicbooleanisShutDown(){
returnexec.isShutdown();
}
/**
*关闭线程池后判断所有任务是否都已完成注意，除非首先调用shutdown或shutdownNow，否则isTerminated永不为true。
*
*@return{@codetrue}:是
{@codefalse}:否
*/
publicbooleanisTerminated(){
returnexec.isTerminated();
}
/**
*请求关闭、发生超时或者当前线程中断无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行。
*
*@paramtimeout最长等待时间
*@paramunit时间单位
*@return{@codetrue}:请求成功
{@codefalse}:请求超时
*@throwsInterruptedException终端异常
*/
publicbooleanawaitTermination(finallongtimeout,finalTimeUnitunit)
throwsInterruptedException{
returnexec.awaitTermination(timeout,unit);
}
/**
*提交一个Callable任务用于执行如果想立即阻塞任务的等待，则可以使用{@coderesult=exec.submit(aCallable).get();}
*形式的构造。
*
*@paramtask任务
*@param泛型
*@return表示任务等待完成的Future,该Future的{@codeget}方法在成功完成时将会返回该任务的结果。
*/
publicFuturesubmit(finalCallabletask){
returnexec.submit(task);
}
/**
*提交一个Runnable任务用于执行
*
*@paramtask任务
*@paramresult返回的结果
*@param泛型
*@return表示任务等待完成的Future,该Future的{@codeget}方法在成功完成时将会返回该任务的结果。
*/
publicFuturesubmit(finalRunnabletask,finalTresult){
returnexec.submit(task,result);
}
/**
*提交一个Runnable任务用于执行
*
*@paramtask任务
*@return表示任务等待完成的Future,该Future的{@codeget}方法在成功完成时将会返回null结果。
*/
publicFuturesubmit(finalRunnabletask){
returnexec.submit(task);
}
/**
*执行给定的任务当所有任务完成时，返回保持任务状态和结果的Future列表。返回列表的所有元素的{@linkFuture#isDone}为{@codetrue}。
*注意，可以正常地或通过抛出异常来终止已完成任务。如果正在进行此操作时修改了给定的collection，则此方法的结果是不确定的。
*
*@paramtasks任务集合
*@param泛型
*@return表示任务的Future列表，列表顺序与给定任务列表的迭代器所生成的顺序相同，每个任务都已完成。
*@throwsInterruptedException如果等待时发生中断，在这种情况下取消尚未完成的任务。
*/
publicList>invokeAll(finalCollection>tasks)
throwsInterruptedException{
returnexec.invokeAll(tasks);
}
/**
*执行给定的任务当所有任务完成或超时期满时(无论哪个首先发生)，返回保持任务状态和结果的Future列表。返回列表的所有元素的{@linkFuture#isDone}为
*{@codetrue}。一旦返回后，即取消尚未完成的任务。注意，可以正常地或通过抛出异常来终止已完成任务。如果此操作正在进行时修改了给定的
*collection，则此方法的结果是不确定的。
*
*@paramtasks任务集合
*@paramtimeout最长等待时间
*@paramunit时间单位
*@param泛型
*@return表示任务的Future列表，列表顺序与给定任务列表的迭代器所生成的顺序相同。如果操作未超时，则已完成所有任务。如果确实超时了，则某些任务尚未完成。
*@throwsInterruptedException如果等待时发生中断，在这种情况下取消尚未完成的任务
*/
publicList>invokeAll(finalCollection>tasks,
finallongtimeout,finalTimeUnitunit)
throwsInterruptedException{
returnexec.invokeAll(tasks,timeout,unit);
}
/**
*执行给定的任务如果某个任务已成功完成（也就是未抛出异常），则返回其结果。一旦正常或异常返回后，则取消尚未完成的任务。
*如果此操作正在进行时修改了给定的collection，则此方法的结果是不确定的。
*
*@paramtasks任务集合
*@param泛型
*@return某个任务返回的结果
*@throwsInterruptedException如果等待时发生中断
*@throwsExecutionException如果没有任务成功完成
*/
publicTinvokeAny(finalCollection>tasks)
throwsInterruptedException,ExecutionException{
returnexec.invokeAny(tasks);
}
/**
*执行给定的任务如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。一旦正常或异常返回后，则取消尚未完成的任务。
*如果此操作正在进行时修改了给定的collection，则此方法的结果是不确定的。
*
*@paramtasks任务集合
*@paramtimeout最长等待时间
*@paramunit时间单位
*@param泛型
*@return某个任务返回的结果
*@throwsInterruptedException如果等待时发生中断
*@throwsExecutionException如果没有任务成功完成
*@throwsTimeoutException如果在所有任务成功完成之前给定的超时期满
*/
publicTinvokeAny(finalCollection>tasks,finallongtimeout,
finalTimeUnitunit)
throwsInterruptedException,ExecutionException,TimeoutException{
returnexec.invokeAny(tasks,timeout,unit);
}
/**
*延迟执行Runnable命令
*
*@paramcommand命令
*@paramdelay延迟时间
*@paramunit单位
*@return表示挂起任务完成的ScheduledFuture，并且其{@codeget()}方法在完成后将返回{@codenull}
*/
publicScheduledFutureschedule(finalRunnablecommand,finallongdelay,
finalTimeUnitunit){
returnscheduleExec.schedule(command,delay,unit);
}
/**
*延迟执行Callable命令
*
*@paramcallable命令
*@paramdelay延迟时间
*@paramunit时间单位
*@param泛型
*@return可用于提取结果或取消的ScheduledFuture
*/
publicScheduledFutureschedule(finalCallablecallable,finallongdelay,
finalTimeUnitunit){
returnscheduleExec.schedule(callable,delay,unit);
}
/**
*延迟并循环执行命令
*
*@paramcommand命令
*@paraminitialDelay首次执行的延迟时间
*@paramperiod连续执行之间的周期
*@paramunit时间单位
*@return表示挂起任务完成的ScheduledFuture，并且其{@codeget()}方法在取消后将抛出异常
*/
publicScheduledFuturescheduleWithFixedRate(finalRunnablecommand,
finallonginitialDelay,finallongperiod,
finalTimeUnitunit){
returnscheduleExec.scheduleAtFixedRate(command,initialDelay,period,unit);
}
/**
*延迟并以固定休息时间循环执行命令
*
*@paramcommand命令
*@paraminitialDelay首次执行的延迟时间
*@paramdelay每一次执行终止和下一次执行开始之间的延迟
*@paramunit时间单位
*@return表示挂起任务完成的ScheduledFuture，并且其{@codeget()}方法在取消后将抛出异常
*/
publicScheduledFuturescheduleWithFixedDelay(finalRunnablecommand,
finallonginitialDelay,finallongdelay,
finalTimeUnitunit){
returnscheduleExec.scheduleWithFixedDelay(command,initialDelay,delay,unit);
}
}
补充知识：Java线程池之ThreadPoolExecutor以及工具类Executors类
首先，介绍线程池的概念。
简单讲，就是有一个“池”内放着一些已经启动的线程，这些线程一直启动，用来执行线程池接受的任务。这些线程我们称为核心线程。
当接收任务过多时，会进入阻塞队列进行存储。
而如果阻塞队列也满，则会创建线程来执行任务，这些任务称为救急线程。救急线程任务结束后会根据存活时间来释放
ThreadPoolExecutor的创建参数就是基于上述的概念：
ThreadPoolExecutor(intcorePoolSize,//核心线程数目 intmaximumPoolSize,//最大线程数=核心线程数+救急线程数 longkeepAliveTime,//救急线程的存活超时时间 TimeUnitunit,//超时时间的单位 BlockingQueueworkQueue,//阻塞队列 ThreadFactorythreadFactory,//线程工厂，主要用于给线程起名， RejectedExecutionHandlerhandler)//拒绝策略，即队列满了后再接受任务怎么处理
会有多种构造方法，常用的是前5个参数的构造。本质上都是调用了这个构造方法
ThreadPoolExecutor类继承自AbstractExecutorService类，而AbstractExecutorService类实现了ExecutorService接口。（因为后面工具类的返回值是ExecutorService接口对象，而不是ThreadPoolExecutor对象）。线程池操作都定义在ExecutorService接口中。
根据不同的需求，会产生不同的线程池。为了方便，有了Executors类来创建一些常用的线程池，注意的是返回值是ExecutorService对象
需求一：固定大小的线程池，即Executors.newFixedThreadPool(corePoolSize)。是只有一定数量的核心数量(参数),即核心数目等于总数目。阻塞队列使用的是LinkedBlockingQueue
本质是调用了
ThreadPoolExecutor(corePoolSize,coreSize，0，TimeUnit.MILLISECONDS,newLinkedBlockingQueue
())
需求二、带缓冲区的线程队列，即Executors.newCachedThreadPool()。没有核心线程，全都是救急线程。超时时间设为60秒。阻塞队列使用的是SynchronousQueue
本质调用：
ThreadPoolExecutor(0,Integer.MAx_VALUE，60L，TimeUnit.SECONDS,newSynchronousQueue
())
需求三：单线程线程池：即Executors.newSingleThreadPool(),即需求一的特殊情况，只有一个核心线程。即：
ThreadPoolExecutor(1,1，0，TimeUnit.MILLISECONDS,newLinkedBlockingQueue
())
以上这篇javaThreadPool线程池的使用,线程池工具类用法说明就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。