CachedThreadPool首先会按照需要创建足够多的线程来执行任务(Task)。随着程序执行的过程,有的线程执行完了任务,可以被重新循环使用时,才不再创建新的线程来执行任务。我们采用《Thinking In Java》中的例子来分析。
首先,任务定义如下(实现了Runnable接口,并且复写了run方法):
public class LiftOff implements Runnable{
protected int countDown = 10; //Default
private static int taskCount = 0;
private final int id = taskCount++;
public LiftOff() {}
public LiftOff(int countDown) {
this.countDown = countDown;
}
public String status() {
return "#" + id + "(" +
(countDown > 0 ? countDown : "LiftOff!") + ") ";
}
@Override
public void run() {
while(countDown-- > 0) {
System.out.print(status());
Thread.yield();
}
}
}
采用CachedThreadPool方式执行编写的客户端程序如下:
public class CachedThreadPool {
public static void main(String[] args) {
ExecutorService exec = Executors.newCachedThreadPool();
for(int i = 0; i < 10; i++) {
exec.execute(new LiftOff());
}
exec.shutdown();
}
}
上面的程序中,有10个任务,采用CachedThreadPool模式,exec没遇到一个LiftOff的对象(Task),就会创建一个线程来处理任务。现在假设遇到到第4个任务时,之前用于处理第一个任务的线程已经执行完成任务了,那么不会创建新的线程来处理任务,而是使用之前处理第一个任务的线程来处理这第4个任务。接着如果遇到第5个任务时,前面那些任务都还没有执行完,那么就会又新创建线程来执行第5个任务。否则,使用之前执行完任务的线程来处理新的任务。
2.FixedThreadPool
FixedThreadPool模式会使用一个优先固定数目的线程来处理若干数目的任务。规定数目的线程处理所有任务,一旦有线程处理完了任务就会被用来处理新的任务(如果有的话)。这种模式与上面的CachedThreadPool是不同的,CachedThreadPool模式下处理一定数量的任务的线程数目是不确定的。而FixedThreadPool模式下最多的线程数目是一定的。
采用FixedThreadPool模式编写客户端程序如下:
public class FixedThreadPool {
public static void main(String[] args) {
//三个线程来执行五个任务
ExecutorService exec = Executors.newFixedThreadPool(3);
for(int i = 0; i < 5; i++) {
exec.execute(new LiftOff());
}
exec.shutdown();
}
}
3.SingleThreadExecutor模式
SingleThreadExecutor模式只会创建一个线程。它和FixedThreadPool比较类似,不过线程数是一个。如果多个任务被提交给SingleThreadExecutor的话,那么这些任务会被保存在一个队列中,并且会按照任务提交的顺序,一个先执行完成再执行另外一个线程。
SingleThreadExecutor模式可以保证只有一个任务会被执行。这种特点可以被用来处理共享资源的问题而不需要考虑同步的问题。
SingleThreadExecutor模式编写的客户端程序如下:
public class SingleThreadExecutor {
public static void main(String[] args) {
ExecutorService exec = Executors.newSingleThreadExecutor();
for (int i = 0; i < 2; i++) {
exec.execute(new LiftOff());
}
}
}
#0(9) #0(8) #0(7) #0(6) #0(5) #0(4) #0(3) #0(2) #0(1) #0(LiftOff!)
#1(9) #1(8) #1(7) #1(6) #1(5) #1(4) #1(3) #1(2) #1(1) #1(LiftOff!)
第一个任务执行完了之后才开始执行第二个任务。
例子:
Java通过Executors提供四种线程池,分别为:
newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
public class ExecutorTest { /*public Executor executor; public ExecutorService executorService; Future<String> fu; Callable<String> call; CompletionService<String> com; Executors executors;*/ public static void main(String []ages) throws Exception{ newFixedThreadPoolTest(); /*newFixedThreadPoolTest(); newFixedThreadPoolTest();*/ newCachedThreadPoolTest(); newSingleThreadExecutorTest(); newScheduledThreadPoolTest(); System.out.println("完成"); } private static void newFixedThreadPoolTest() throws Exception{ ExecutorService executor = Executors.newFixedThreadPool(2); for (int i = 0; i < 6; i++) { final int index = i+1; System.out.println("task:"+(i+1)); Runnable run = new Runnable() { @Override public void run() { System.out.println("thread start " + index); try { Thread.sleep(1000); } catch (Exception e) { e.printStackTrace(); } System.out.println("thread end "+ index); } }; executor.execute(run); } //Thread.sleep(7000); //当线程池调用该方法时,线程池的状态则立刻变成SHUTDOWN状态,以后不能再往线程池中添加任何任务,否则将会抛出RejectedExecutionException异常。 //但是,此时线程池不会立刻退出,直到添加到线程池中的任务都已经处理完成,才会退出。 与它相似的还有一个shutdownNow(),它通过调用Thread.interrupt来实现线程的立即退出 executor.shutdown(); //awaitTermination阻塞当前线程,等待剩余任务执行完,然后继续往下执行。如果不适用await,那么shutdown之后,很可能导致剩余任务得不到执行(整个程序退出),或是执行出现异常 executor.awaitTermination(7000, TimeUnit.MILLISECONDS); System.err.println("完成线程!"); } public static void newCachedThreadPoolTest() throws Exception{ //如果超过60s没有新的任务线程自己退出 ExecutorService executorService = Executors.newCachedThreadPool(); for (int i = 0; i < 6; i++) { final int index = i+1; Runnable run = new Runnable() { @Override public void run() { System.out.println("cached线程池线程start"+index); try { Thread.sleep(1500); System.out.println("cached 线程结束end"+index); } catch (Exception e) { e.printStackTrace(); } } }; executorService.execute(run); } //如果 不写这个默认60s关闭线程池线程自动关闭 //executorService.shutdown(); } public static void newSingleThreadExecutorTest() throws Exception{ ExecutorService executorService = Executors.newSingleThreadExecutor(); for (int i = 0; i < 6; i++) { final int index = i+1; Runnable run =new Runnable() { @Override public void run() { System.out.println("SingleThread线程池线程start"+index); try { Thread.sleep(1500); System.out.println("SingleThread 线程结束end"+index); } catch (Exception e) { e.printStackTrace(); } } }; executorService.execute(run); } executorService.shutdown(); } public static void newScheduledThreadPoolTest() throws Exception{ ScheduledExecutorService serExecutorService = Executors.newScheduledThreadPool(10); int index = 1; Runnable run = new Runnable() { @Override public void run() { System.out.println("scheduled线程Start"); try { Thread.sleep(1500); } catch (Exception e) { e.printStackTrace(); } } }; serExecutorService.execute(run); //从上面程序运行隔8秒开始执行,没过3秒执行一次 serExecutorService.scheduleWithFixedDelay(run, 8, 3,TimeUnit.SECONDS); } }