java线程实例
❶ java澶氱嚎绋嫔埯瀛﹁呮寚鍗楋纸3锛夛细浣跨敤Runnable鎺ュ彛鍒涘缓绾跨▼
銆銆涓娄竴绡 Java澶氱嚎绋嫔埯瀛﹁呮寚鍗楋纸 锛 鐢═hread绫诲垱寤虹嚎绋
銆銆瀹炵幇Runnable鎺ュ彛镄勭被蹇呴’浣跨敤Thread绫荤殑瀹炰緥镓嶈兘鍒涘缓绾跨▼ 阃氲繃Runnable鎺ュ彛鍒涘缓绾跨▼鍒嗕负涓ゆ
銆銆 灏嗗疄鐜癛unnable鎺ュ彛镄勭被瀹炰緥鍖
銆銆 寤虹珛涓涓猅hread瀵硅薄 骞跺皢绗涓姝ュ疄渚嫔寲钖庣殑瀵硅薄浣滀负鍙傛暟浼犲叆Thread绫荤殑鏋勯犳柟娉
銆銆链钖庨氲繃Thread绫荤殑start鏂规硶寤虹珛绾跨▼
銆銆涓嬮溃镄勪唬镰佹紨绀轰简濡备綍浣跨敤Runnable鎺ュ彛𨱒ュ垱寤虹嚎绋
銆銆 packagemythread;{publicvoidrun(){System out println(Thread currentThread() getName());}publicstaticvoidmain(String[]args){MyRunnablet =newMyRunnable();MyRunnablet =newMyRunnable();Threadthread =newThread(t MyThread );Threadthread =newThread(t );thread setName( MyThread );thread start();thread start();}}
銆銆涓婇溃浠ｇ爜镄勮繍琛岀粨鏋滃备笅
lishixin/Article/program/Java/gj/201311/27466
❷ java常用的几种线程池实例讲解
下面给你介绍4种线程池：
1、newCachedThreadPool：
底层：返回ThreadPoolExecutor实例，corePoolSize为0；maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为60L；unit为TimeUnit.SECONDS；workQueue为SynchronousQueue(同步队列)
通俗：当有新任务到来，则插入到SynchronousQueue中，由于SynchronousQueue是同步队列，因此会在池中寻找可用线程来执行，若有可以线程则执行，若没有可用线程则创建一个线程来执行该任务；若池中线程空闲时间超过指定大小，则该线程会被销毁。
适用：执行很多短期异步的小程序或者负载较轻的服务器
2、newFixedThreadPool：
底层：返回ThreadPoolExecutor实例，接收参数为所设定线程数量nThread，corePoolSize为nThread，maximumPoolSize为nThread；keepAliveTime为0L(不限时)；unit为：TimeUnit.MILLISECONDS；WorkQueue为：new LinkedBlockingQueue<Runnable>()无解阻塞队列
通俗：创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不在添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：执行长期的任务，性能好很多
3、newSingleThreadExecutor
底层：包装的ThreadPoolExecutor实例，corePoolSize为1；maximumPoolSize为1；keepAliveTime为0L；unit为：TimeUnit.MILLISECONDS；workQueue为：new LinkedBlockingQueue<Runnable>()无解阻塞队列
通俗：创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：一个任务一个任务执行的场景
4、NewScheledThreadPool:
底层：创建ScheledThreadPoolExecutor实例，corePoolSize为传递来的参数，maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为0；unit为：TimeUnit.NANOSECONDS；workQueue为：new DelayedWorkQueue()一个按超时时间升序排序的队列
通俗：创建一个固定大小的线程池，线程池内线程存活时间无限制，线程池可以支持定时及周期性任务执行，如果所有线程均处于繁忙状态，对于新任务会进入DelayedWorkQueue队列中，这是一种按照超时时间排序的队列结构
适用：周期性执行任务的场景
最后给你说一下线程池任务执行流程：
当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
当workQueue已满，且maximumPoolSize>corePoolSize时，新提交任务会创建新线程执行任务
当提交任务数超过maximumPoolSize时，新提交任务由RejectedExecutionHandler处理
当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭
❸ Java多线程之ThreadPoolExecutor原理（图文代码实例详解）
ThreadPoolExecutor是Java的线程池并发代名词,多线程开发基本都是基于这个去做具体的业务开发。虽然觉得自己回了，网上帖子已经有很多的文章写这个，但是是自己一一点写的，终归是要比看别人的理解更加深刻，所以最近自己在对java知识的系统梳理。那么接下来主要分析下这个多线程框架的原理。
ThreadPoolExecutor的构造函数以成员变量介绍publicThreadPoolExecutor(intcorePoolSize,intmaximumPoolSize,longkeepAliveTime,TimeUnitunit,BlockingQueue<Runnable>workQueue,ThreadFactorythreadFactory,){面试靠的最多是这个构造函数中7个参数的作用，
corePoolSize是核心线程数,即使线程是空闲的,线程池一直保持的的线程数,除非allowCoreThreadTimeOut参数设置为true
maximumPoolSize线程池最大线程数
keepAliveTimeunit线程存活时间和时间单位
workQueue是任务队列,是用来保持task,该队列保持住了Runnable的任务,通过调用线程池的execute的方法.
threadFactory创建线程的工厂
RejectedExecutionHandler是当线程数超过限制以及队列也满了,需要执行的拒绝策略.
成员变零
privatefinalAtomicIntegerctl=newAtomicInteger(ctlOf(RUNNING,0));privatestaticfinalintCOUNT_BITS=Integer.SIZE-3;privatestaticfinalintCAPACITY=(1<<COUNT_BITS)-1;//线程容量//runStateisstoredinthehigh-=-1<<COUNT_BITS;privatestaticfinalintSHUTDOWN=0<<COUNT_BITS;privatestaticfinalintSTOP=1<<COUNT_BITS;privatestaticfinalintTIDYING=2<<COUNT_BITS;=3<<COUNT_BITS;面试最喜欢问的是ctl变量的代表什么意义？ctl变量的的的用高3位表示线程池的状态，用低29位表示线程个数，两者通过|操作，拼接出ctl变量，也就是线程池的最大线程数capacity是(2^29)-1。
线程池状态RUNNING运行状态-1<<29表示线程池可以接新的任务并且处理队列任务
SHUTDOWN关闭状态态-1<<29表示线程池不接受新的线程池任务但是可以处理队列中的任务
STOP停止状态1<<29表示线程池不接受新的线程池任务也不处理队列中的任务并且中断线程池里中正在执行的任务
TIDYING2<<29表示所有的线程池都已经中断了，线程数为0，线程状态转为为TIDYING,将执行terminated钩子函数
TERMINATED3<<29表示所有terminated方法都已经执行完成。
线程状态之间装换图首先我们来看平时业务代码是提交任务到线程池执行的函数是通过execute或者submit方法，区别就是submit返回具有Future，execute返回void,的、那么接下来我们主要分析execute的执行流程，submit涉及到线程异步返回，之后会另外单独分析，那么下面这个execute函数就能看出线程池的整个执行流程，
publicvoidexecute(Runnablecommand){if(command==null)thrownewNullPointerException();/**Proceedin3steps:**1.,tryto**task.*workerCount,*threadswhenitshouldn't,byreturningfalse.**2.,thenwestillneed*todouble-*()orthat*.Sowe**stopped,.**3.Ifwecannotqueuetask,thenwetrytoaddanew*thread.Ifitfails,*andsorejectthetask.*/intc=ctl.get();if(workerCountOf(c)<corePoolSize){if(addWorker(command,true))return;c=ctl.get();}if(isRunning(c)&&workQueue.offer(command)){intrecheck=ctl.get();if(!isRunning(recheck)&&remove(command))reject(command);elseif(workerCountOf(recheck)==0)//当线程池的核心线程数设置为0情况下，那么这时workerCountOf(recheck)为0,这时就开启非线程数处理队列任务addWorker(null,false);}elseif(!addWorker(command,false))reject(command);}线程池执行任务流程图如下:
我相信大概的流程一般同学是清楚的：
当线程数的Worker线程<corePoolSize创建核心线程数执行
当线程数的Worker线程>corePoolSize，将任务加入任务队列中
则当corePoolSize<maxPoolsize，则新增非核心线程执行任务
当队列满了，线程数也已经达到maxPoolsize，则执行拒绝策略
实际源码中执行流程还有一些小细节容易被忽略的地点
重新检查线程的状态以及检查线程池的线程数的流程
线程池新增工作线程的流程线程池新增工作任务主要addWorker方法。由于代码比较长，我就在代码里写好注释
privatebooleanaddWorker(RunnablefirstTask,booleancore){retry:for(;;){intc=ctl.get();intrs=runStateOf(c);//.if(rs>=SHUTDOWN&&//第一个条件:线程至少不是运行状态,那么就是shutdownstoptidying,terminated状态!(rs==SHUTDOWN&&firstTask==null&&!workQueue.isEmpty()))//第二个条件:当前线程池是shutdown状态且任务队列非空并且工作任务第一个任务是空的取反条件，这个含义是当除了SHUTDOWN状态且第一个任务为空且任务队列不为空//情况下，直接返回false，增加Work线程失败returnfalse;for(;;){intwc=workerCountOf(c);if(wc>=CAPACITY||wc>=(core?corePoolSize:maximumPoolSize))returnfalse;if((c))breakretry;c=ctl.get();//Re-readctlif(runStateOf(c)!=rs)continueretry;//;retryinnerloop}}booleanworkerStarted=false;booleanworkerAdded=false;Workerw=null;try{w=newWorker(firstTask);finalThreadt=w.thread;if(t!=null){finalReentrantLockmainLock=this.mainLock;mainLock.lock();try{//Recheckwhileholdinglock.////shutdownbeforelockacquired.intrs=runStateOf(ctl.get());if(rs<SHUTDOWN||//线程池是running状态(rs==SHUTDOWN&&firstTask==null)){//线程池处于shutdown状态并且第一个task为空if(t.isAlive())//();//加入工作线程的集合workers.add(w);ints=workers.size();if(s>largestPoolSize)//记录最大线程数largestPoolSize=s;workerAdded=true;}}finally{-mainLock.unlock();-}-if(workerAdded){-t.start();workerStarted=true;}}}finally{if(!workerStarted)addWorkerFailed(w);}returnworkerStarted;}添加工作线程主要步骤
检查线程池的运行状态以及队列是否是空，增加线程。为什么增加这个判断，主要是因为线程池是多线程的随便可能另外调用shutdown等方法关闭线程池，所以做每一步之前都要再次check线程池的状态，其中比较重要的点是线程池在除了Running状态，其他的只有shutdow状态，且队列任务非空的情况，才能增加work线程处理任务。
判断线程池的线程是核心线程数，然后就判断大于核心线程数,如果不是增加的核心线程数，然后通过CAS增加线程数加1，然后re-read的ctl的现在的状态是否刚开始进入循环的状态保持一致。
创建Worker对象，它的第一个参数Runable就是执行的第一个task，然后获取mainLock的重入锁,然后再次判断线程池的状态是否是shutdown状态，然后将Worker对象加入工作线程的Set集合中,判断是大于largePoolSize，则将workSet的size赋值largePoolSize,然后赋值workerAdded为true,接下来在finnally中workerAdded为true，则调用Worker的start方法启动该Worker线程，
如果WorkerAdded失败，则从Worder的Set移除刚才加入Worker线程，并将线程池的线程数减1，
工作线程Worker的执行流程首先来看下Work的类的成员变量的构造函数,从下面的Work的代码，可以看到它是实现了RUnnable接口，上一节Worker启动是调用了它的start方法，真正由操作系统调度执行的其run方法，那么接下来重点看下run的工作流程。
able{/***,butweprovidea*.*/=6138294804551838833L;/**Threadthisworkerisrunningin.Nulliffactoryfails.*/finalThreadthread;/**Initialtasktorun.Possiblynull.*/RunnablefirstTask;/**Per-threadtaskcounter*/volatilelongcompletedTasks;/***.*@paramfirstTaskthefirsttask(nullifnone)*/Worker(RunnablefirstTask){//初始化状态为-1，表示不能被中断setState(-1);//.firstTask=firstTask;this.thread=getThreadFactory().newThread(this);}下面代码中Work的run直接调用runWork，并传入自身对象,开始一个循环判断第一个任务后者从任务队列中取任务不为空，就开始上锁，然后执行任务，如果任务队列为空了，则处理Work的退出。
/***/publicvoidrun(){//直接调用runWorker函数runWorker(this);}finalvoidrunWorker(Workerw){//Wokder当前线程Threadwt=Thread.currentThread();Runnabletask=w.firstTask;w.firstTask=null;//将state值赋值为0，这样就运行中断w.unlock();//=true;try{//循环判断第一个Task获取从获取任务while(task!=null||(task=getTask())!=null){//获取当前Work的锁，处理任务，也就是当前Work线程处理是同步处理任务的w.lock();//Ifpoolisstopping,ensurethreadisinterrupted;//ifnot,ensurethreadisnotinterrupted.This//////线程池的状态至少是stop，即使stop，tidying.terminated状态if((runStateAtLeast(ctl.get(),STOP)//检查线程是否中断且清楚中断||(Thread.interrupted()&&//再次检查线程池的状态至少是STOPrunStateAtLeast(ctl.get(),STOP)))&&//再次判断是否中断!wt.isInterrupted())//中断线程wt.interrupt();try{//执行业务任务前处理(钩子函数)beforeExecute(wt,task);Throwablethrown=null;try{//这里就是执行提交线程池的Runnable的任务的run方法task.run();}catch(RuntimeExceptionx){thrown=x;throwx;}catch(Errorx){thrown=x;throwx;}catch(Throwablex){thrown=x;thrownewError(x);}finally{//执行业务任务后处理(钩子函数)afterExecute(task,thrown);}}finally{//执行结束重置为空，回到while循环拿下一个task=null;//处理任务加1w.completedTasks++;//释放锁，处理下一个任务w.unlock();}}//代码执行到这里，代表业务的任务没有异常，不然不会走到这里，//因为上一层try没有catch异常的，而业务执行出现异常，最里层//虽然catch了异常，但是也都通过throw向外抛出completedAbruptly=false;}finally{//如果循环结束，则处理Work退出工作，代表任务拿不到任务，即任务队列没有任务了processWorkerExit(w,completedAbruptly);}}下面就来看下getTask获取任务队列的处理逻辑、如果这里返回null，即runWorker循环退出，则会处理finnaly中processWorkExit,处理Work线程的退出,下面是getWork返回null的情况:
如果线程池状态值至少是SHUTDOWN状态,并且线程池状态值至少是STOP状态，或者是任务队列是空，则将线程池的workcout减1，并返回null，
计算线程池中线程池的数量，如果线程数量大于最大线程数量,或者allowCoreThreadTimeOut参数为true或者线程数大于并且任务队列为空，则将线程池减1，并返回null，
privateRunnablegetTask(){//超时标志booleantimedOut=false;//Didthelastpoll()timeout?for(;;){//获取线程状态intc=ctl.get();//线程状态intrs=runStateOf(c);//.//如果线程池状态值至少是SHUTDOWN状态,if(rs>=SHUTDOWN线程池状态值至少是STOP状态，或者是任务队列是空&&(rs>=STOP||workQueue.isEmpty())){//CAS将worker线程数减1decrementWorkerCount();returnnull;}//计算线程池线程数量intwc=workerCountOf(c);//Areworkerssubjecttoculling?//allowCoreThreadTimeOut参数设置为true,或则线程池的线程数大于corePoolSize,表示需要超时的Worker需要退出，booleantimed=allowCoreThreadTimeOut||wc>corePoolSize;//线程数大于最大线程数||已经超时if((wc>maximumPoolSize||(timed&&timedOut))//线程数大于1或者任务队列为空&&(wc>1||workQueue.isEmpty())){//CAS将线程数减1if((c))returnnull;continue;}try{//需要处理超时的Worker，则获取任务队列中任务等待的时间//就是线程池构造函数中keepAliveTime时间，如果不处理超时的Worker//则直接调用take一直阻塞等待任务队列中有任务，拿到就返回Runnale任务Runnabler=timed?workQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS):workQueue.take();if(r!=null)returnr;timedOut=true;}catch(InterruptedExceptionretry){timedOut=false;}}}Worker的退出处理:1从上面分析知道completedAbruptly是任务执行时是否出现异常标志，如果任务执行过程出错，则将线程池的线程数量减12.加线程池的mainLock的全局锁，这里主要区分Worker执行任务中，拿的是Worker内部的锁，完成任务加1，将worker从Worker的集合移除,3.执行tryTerminate函数，是否线程池线程池是否关闭4.根据线程池状态是否补充非核心的Worker线程去处理
privatevoidprocessWorkerExit(Workerw,booleancompletedAbruptly){//任务执行时出现异常，则减去工作if(completedAbruptly)//Ifabrupt,thenworkerCountwasn'tadjusteddecrementWorkerCount();//拿到线程池的主锁finalReentrantLockmainLock=this.mainLock;//加锁mainLock.lock();try{//完成任务加1completedTaskCount+=w.completedTasks;//将worker从Worker的集合移除workers.remove(w);}finally{mainLock.unlock();}//尝试线程池关闭tryTerminate();//获取线程池的ctlintc=ctl.get();//如果线程池的状态值小于STOP，即使SHUTDOWNRUNNINGif(runStateLessThan(c,STOP)){//任务执行没有异常if(!completedAbruptly){//allowCoreThreadTimeOut参数true，则min=0,表示不需要线程常驻。//负责是有corePoolSize个线程常驻线程池intmin=allowCoreThreadTimeOut?0:corePoolSize;if(min==0&&!workQueue.isEmpty())min=1;//如果线程池数大于最小，也就是不需要补充线程执行任务队列的任务if(workerCountOf(c)>=min)return;//replacementnotneeded}//走到这里表示线程池的线程数为0，而任务队列又不为空，得补充一个线程处理任务addWorker(null,false);}}t
❹ Java实现通用线程池
线程池通俗的描述就是预先创建若干空闲线程 等到需要用多线程去处理事务的时候去唤醒某些空闲线程执行处理任务 这样就省去了频繁创建线程的时间 因为频 繁创建线程是要耗费大量的CPU资源的 如果一个应用程序需要频繁地处理大量并发事务 不断的创建销毁线程往往会大大地降低系统的效率 这时候线程池就派 上用场了
本文旨在使用Java语言编写一个通用的线程池 当需要使用线程池处理事务时 只需按照指定规范封装好事务处理对象 然后用已有的线程池对象去自动选择空 闲线程自动调用事务处理对象即可 并实现线程池的动态修改（修改当前线程数 最大线程数等） 下面是实现代码
//ThreadTask java
package polarman threadpool;
/** *//**
*线程任务
* @author ryang
*
*/
public interface ThreadTask {
public void run();
}
//PooledThread java
package polarman threadpool;
import java util Collection; import java util Vector;
/** *//**
*接受线程池管理的线程
* @author ryang
*
*/
public class PooledThread extends Thread {
protected Vector tasks = new Vector();
protected boolean running = false;
protected boolean stopped = false;
protected boolean paused = false;
protected boolean killed = false;
private ThreadPool pool;
public PooledThread(ThreadPool pool) { this pool = pool;
}
public void putTask(ThreadTask task) { tasks add(task);
}
public void putTasks(ThreadTask[] tasks) { for(int i= ; i<tasks length; i++) this tasks add(tasks[i]);
}
public void putTasks(Collection tasks) { this tasks addAll(tasks);
}
protected ThreadTask popTask() { if(tasks size() > ) return (ThreadTask)tasks remove( );
else
return null;
}
public boolean isRunning() {
return running;
}
public void stopTasks() {
stopped = true;
}
public void stopTasksSync() {
stopTasks();
while(isRunning()) { try {
sleep( );
} catch (InterruptedException e) {
}
}
}
public void pauseTasks() {
paused = true;
}
public void pauseTasksSync() {
pauseTasks();
while(isRunning()) { try {
sleep( );
} catch (InterruptedException e) {
}
}
}
public void kill() { if(!running)
interrupt();
else
killed = true;
}
public void killSync() {
kill();
while(isAlive()) { try {
sleep( );
} catch (InterruptedException e) {
}
}
}
public synchronized void startTasks() {
running = true;
this notify();
}
public synchronized void run() { try { while(true) { if(!running || tasks size() == ) { pool notifyForIdleThread(); //System out println(Thread currentThread() getId() + : 空闲 ); this wait(); }else {
ThreadTask task;
while((task = popTask()) != null) { task run(); if(stopped) {
stopped = false;
if(tasks size() > ) { tasks clear(); System out println(Thread currentThread() getId() + : Tasks are stopped );
break;
}
}
if(paused) {
paused = false;
if(tasks size() > ) { System out println(Thread currentThread() getId() + : Tasks are paused );
break;
}
}
}
running = false;
}
if(killed) {
killed = false;
break;
}
}
}catch(InterruptedException e) {
return;
}
//System out println(Thread currentThread() getId() + : Killed );
}
}
//ThreadPool java
package polarman threadpool;
import java util Collection; import java util Iterator; import java util Vector;
/** *//**
*线程池
* @author ryang
*
*/
public class ThreadPool {
protected int maxPoolSize;
protected int initPoolSize;
protected Vector threads = new Vector();
protected boolean initialized = false;
protected boolean hasIdleThread = false;
public ThreadPool(int maxPoolSize int initPoolSize) { this maxPoolSize = maxPoolSize; this initPoolSize = initPoolSize;
}
public void init() {
initialized = true;
for(int i= ; i<initPoolSize; i++) {
PooledThread thread = new PooledThread(this);
thread start(); threads add(thread);
}
//System out println( 线程池初始化结束 线程数= + threads size() + 最大线程数= + maxPoolSize);
}
public void setMaxPoolSize(int maxPoolSize) { //System out println( 重设最大线程数 最大线程数= + maxPoolSize); this maxPoolSize = maxPoolSize;
if(maxPoolSize < getPoolSize())
setPoolSize(maxPoolSize);
}
/** *//**
*重设当前线程数
* 若需杀掉某线程 线程不会立刻杀掉 而会等到线程中的事务处理完成* 但此方法会立刻从线程池中移除该线程 不会等待事务处理结束
* @param size
*/
public void setPoolSize(int size) { if(!initialized) {
initPoolSize = size;
return;
}else if(size > getPoolSize()) { for(int i=getPoolSize(); i<size && i<maxPoolSize; i++) {
PooledThread thread = new PooledThread(this);
thread start(); threads add(thread);
}
}else if(size < getPoolSize()) { while(getPoolSize() > size) { PooledThread th = (PooledThread)threads remove( ); th kill();
}
}
//System out println( 重设线程数 线程数= + threads size());
}
public int getPoolSize() { return threads size();
}
protected void notifyForIdleThread() {
hasIdleThread = true;
}
protected boolean waitForIdleThread() {
hasIdleThread = false;
while(!hasIdleThread && getPoolSize() >= maxPoolSize) { try { Thread sleep( ); } catch (InterruptedException e) {
return false;
}
}
return true;
}
public synchronized PooledThread getIdleThread() { while(true) { for(Iterator itr=erator(); itr hasNext();) { PooledThread th = (PooledThread)itr next(); if(!th isRunning())
return th;
}
if(getPoolSize() < maxPoolSize) {
PooledThread thread = new PooledThread(this);
thread start(); threads add(thread);
return thread;
}
//System out println( 线程池已满 等待 );
if(waitForIdleThread() == false)
return null;
}
}
public void processTask(ThreadTask task) {
PooledThread th = getIdleThread();
if(th != null) { th putTask(task); th startTasks();
}
}
public void processTasksInSingleThread(ThreadTask[] tasks) {
PooledThread th = getIdleThread();
if(th != null) { th putTasks(tasks); th startTasks();
}
}
public void processTasksInSingleThread(Collection tasks) {
PooledThread th = getIdleThread();
if(th != null) { th putTasks(tasks); th startTasks();
}
}
}
下面是线程池的测试程序
//ThreadPoolTest java
import java io BufferedReader; import java io IOException; import java io InputStreamReader;
import polarman threadpool ThreadPool; import polarman threadpool ThreadTask;
public class ThreadPoolTest {
public static void main(String[] args) { System out println( quit 退出 ); System out println( task A 启动任务A 时长为 秒 ); System out println( size 设置当前线程池大小为 ); System out println( max 设置线程池最大线程数为 ); System out println();
final ThreadPool pool = new ThreadPool( ); pool init();
Thread cmdThread = new Thread() { public void run() {
BufferedReader reader = new BufferedReader(new InputStreamReader(System in));
while(true) { try { String line = reader readLine(); String words[] = line split( ); if(words[ ] equalsIgnoreCase( quit )) { System exit( ); }else if(words[ ] equalsIgnoreCase( size ) && words length >= ) { try { int size = Integer parseInt(words[ ]); pool setPoolSize(size); }catch(Exception e) {
}
}else if(words[ ] equalsIgnoreCase( max ) && words length >= ) { try { int max = Integer parseInt(words[ ]); pool setMaxPoolSize(max); }catch(Exception e) {
}
}else if(words[ ] equalsIgnoreCase( task ) && words length >= ) { try { int timelen = Integer parseInt(words[ ]); SimpleTask task = new SimpleTask(words[ ] timelen * ); pool processTask(task); }catch(Exception e) {
}
}
} catch (IOException e) { e printStackTrace();
}
}
}
};
cmdThread start();
/**//*
for(int i= ; i< ; i++){
SimpleTask task = new SimpleTask( Task + i (i+ )* ); pool processTask(task);
}*/
}
}
class SimpleTask implements ThreadTask {
private String taskName;
private int timeLen;
public SimpleTask(String taskName int timeLen) { this taskName = taskName; this timeLen = timeLen;
}
public void run() { System out println(Thread currentThread() getId() +
: START TASK + taskName + );
try { Thread sleep(timeLen); } catch (InterruptedException e) {
}
System out println(Thread currentThread() getId() +
: END TASK + taskName + );
}
}
使用此线程池相当简单 下面两行代码初始化线程池
ThreadPool pool = new ThreadPool( ); pool init();
要处理的任务实现ThreadTask 接口即可（如测试代码里的SimpleTask） 这个接口只有一个方法run()
两行代码即可调用
lishixin/Article/program/Java/hx/201311/27203