ExecutorService生命周期
ExecutorService接口继承了Executor接口,定义了一些生命周期的方法
public interface ExecutorService extends Executor { void shutdown(); List<Runnable> shutdownNow(); boolean isShutdown(); boolean isTerminated(); boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException; }
本文,我们逐一分析里面的每个方法。
首先,我们需要创建一个任务代码,这段任务代码主要是随机生成含有10个字符的字符串
package org.threadtest; import java.util.Random; import java.util.concurrent.Callable; public class Task1 implements Callable<String> { @Override public String call() throws Exception { String base = "abcdefghijklmnopqrstuvwxyz0123456789"; Random random = new Random(); StringBuffer sb = new StringBuffer(); for (int i = 0; i < 10; i++) { int number = random.nextInt(base.length()); sb.append(base.charAt(number)); } return sb.toString(); } }
然后,我们还需要一个长任务,这里我们默认是沉睡10秒,
package org.threadtest; import java.util.concurrent.Callable; import java.util.concurrent.TimeUnit; public class LongTask implements Callable<String> { @Override public String call() throws Exception { TimeUnit.SECONDS.sleep(10); return "success"; } }
OK,所有前期准备完毕,下面我们就来分析一下ExecutorService接口中和生命周期有关的这些方法:
1、shutdown方法:这个方法会平滑地关闭ExecutorService,当我们调用这个方法时,ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类:一类是已经在执行的,另一类是还没有开始执行的),当所有已经提交的任务执行完毕后将会关闭ExecutorService。这里我们先不举例在下面举例。
2、awaitTermination方法:这个方法有两个参数,一个是timeout即超时时间,另一个是unit即时间单位。这个方法会使线程等待timeout时长,当超过timeout时间后,会监测ExecutorService是否已经关闭,若关闭则返回true,否则返回false。一般情况下会和shutdown方法组合使用。例如:
package org.threadtest; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class Run { public static void main(String[] args) throws Exception { ExecutorService service = Executors.newFixedThreadPool(4); service.submit(new Task1()); service.submit(new Task1()); service.submit(new LongTask()); service.submit(new Task1()); service.shutdown(); while (!service.awaitTermination(1, TimeUnit.SECONDS)) { System.out.println("线程池没有关闭"); } System.out.println("线程池已经关闭"); } }
这段代码中,我们在第三次提交了一个长任务,这个任务将执行10秒沉睡,紧跟着执行了一次shutdown()方法,假设:这时ExecutorService被立即关闭,下面调用service.awaitTermination(1, TimeUnit.SECONDS)方法时应该返回true,程序执行结果应该只会打印出:“线程池已经关闭”。但是,真实的运行结果如下:
线程池没有关闭 线程池没有关闭 线程池没有关闭 线程池没有关闭 线程池没有关闭 线程池没有关闭 线程池没有关闭 线程池没有关闭 线程池没有关闭 线程池已经关闭
这说明我们假设错误,service.awaitTermination(1, TimeUnit.SECONDS)每隔一秒监测一次ExecutorService的关闭情况,而长任务正好需要执行10秒,因此会在前9秒监测时ExecutorService为未关闭状态,而在第10秒时已经关闭,因此第10秒时输出:线程池已经关闭。这也验证了shutdown方法关闭ExecutorService的条件。
3、shutdownNow方法:这个方法会强制关闭ExecutorService,它将取消所有运行中的任务和在工作队列中等待的任务,这个方法返回一个List列表,列表中返回的是等待在工作队列中的任务。例如:
package org.threadtest; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class Run2 { public static void main(String[] args) throws InterruptedException { ExecutorService service = Executors.newFixedThreadPool(3); service.submit(new LongTask()); service.submit(new LongTask()); service.submit(new LongTask()); service.submit(new LongTask()); service.submit(new LongTask()); List<Runnable> runnables = service.shutdownNow(); System.out.println(runnables.size()); while (!service.awaitTermination(1, TimeUnit.MILLISECONDS)) { System.out.println("线程池没有关闭"); } System.out.println("线程池已经关闭"); } }
这段代码中,我们限制了线程池的长度是3,提交了5个任务,这样将有两个任务在工作队列中等待,当我们执行shutdownNow方法时,ExecutorService被立刻关闭,所以在service.awaitTermination(1, TimeUnit.MILLISECONDS)方法校验时返回的是false,因此没有输出:线程池没有关闭。而在调用shutdownNow方法时,我们接受到了一个List,这里包含的是在工作队列中等待执行的任务,由于线程池长度为3,且执行的都是长任务,所以当提交了三个任务后线程池已经满了,剩下的两次提交只能在工作队列中等待,因此我们看到runnables的大小为2,结果如下:
2 线程池已经关闭
4、isTerminated方法:这个方法会校验ExecutorService当前的状态是否为“TERMINATED”即关闭状态,当为“TERMINATED”时返回true否则返回false。例如:
private static void testIsTerminate() throws Exception{ ExecutorService service = Executors.newFixedThreadPool(3); service.submit(new Task1()); service.submit(new Task1()); service.submit(new LongTask()); service.shutdown(); System.out.println(System.currentTimeMillis()); while (!service.isTerminated()) { } System.out.println(System.currentTimeMillis()); }
这段代码我们执行了两个正常的任务和一个长任务,然后调用了shutdown方法,我们知道调用shutdown方法并不会立即关闭ExecutorService,这时我们记录一下监测循环执行前的时间,在没有关闭前我们一直进入一个空循环中,直到 ExecutorService关闭后退出循环,这里我们知道长任务执行时间大约为10秒,我们看一下上述程序运行结果:
1415277071553 1415277081553 结果相差 10*1000毫秒
这10秒正好是长任务执行的时间,因此在 ExecutorService正常关闭后isTerminated方法返回true。
5、isShutdown方法:这个方法在ExecutorService关闭后返回true,否则返回false。方法比较简单不再举例。
以上讨论是基于ThreadPoolExecutor的实现,不同的实现会有所不同需注意。
ExecutorService线程池
ExecutorService建立多线程的步骤:
1。定义线程类 |
class Handler implements Runnable{ } |
2。建立ExecutorService线程池 |
ExecutorService executorService =Executors.newCachedThreadPool(); //或者 int cpuNums = Runtime.getRuntime().availableProcessors();//获取当前系统的CPU 数目 ExecutorService executorService=Executors.newFixedThreadPool(cpuNums * POOL_SIZE); //ExecutorService通常根据系统资源情况灵活定义线程池大小 |
3。调用线程池操作 |
//循环操作,成为daemon,把新实例放入Executor池中 while(true){ executorService.execute(newHandler(socket)); // class Handler implements Runnable{ 或者 executorService.execute(createTask(i)); //private static Runnable createTask(final int taskID) } execute(Runnable对象)方法 其实就是对Runnable对象调用start()方法 (当然还有一些其他后台动作,比如队列,优先级,IDLE timeout,active激活等) |
几种不同的ExecutorService线程池对象
1.newCachedThreadPool() |
-缓存型池子,先查看池中有没有以前建立的线程,如果有,就reuse.如果没有,就建一个新的线程加入池中 -缓存型池子通常用于执行一些生存期很短的异步型任务 -能reuse的线程,必须是timeout IDLE内的池中线程,缺省timeout是60s,超过这个IDLE时长,线程实例将被终止及移出池。 |
2. newFixedThreadPool | -newFixedThreadPool与cacheThreadPool差不多,也是能reuse就用,但不能随时建新的线程 -其独特之处:任意时间点,最多只能有固定数目的活动线程存在,此时如果有新的线程要建立,只能放在另外的队列中等待,直到当前的线程中某个线程终止直接被移出池子 -和cacheThreadPool不同,FixedThreadPool没有IDLE机制(可能也有,但既然文档没提,肯定非常长,类似依赖上层的TCP或UDPIDLE机制之类的),所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程,多用于服务器 -从方法的源代码看,cache池和fixed池调用的是同一个底层池,只不过参数不同: fixed池线程数固定,并且是0秒IDLE(无IDLE) cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力),60秒IDLE |
3.ScheduledThreadPool | -调度型线程池 -这个池子里的线程可以按schedule依次delay执行,或周期执行 |
4.SingleThreadExecutor | -单例线程,任意时间池中只能有一个线程 -用的是和cache池和fixed池相同的底层池,但线程数目是1-1,0秒IDLE(无IDLE) |
上面四种线程池,都使用Executor的缺省线程工厂建立线程,也可单独定义自己的线程工厂
下面是缺省线程工厂代码:
package org.threadtest; import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicInteger; public class DefaultThreadFactory implements ThreadFactory { static final AtomicInteger poolNumber = new AtomicInteger(1); final ThreadGroup group; final AtomicInteger threadNumber = new AtomicInteger(1); final String namePrefix; DefaultThreadFactory() { SecurityManager s = System.getSecurityManager(); group = (s != null)? s.getThreadGroup() :Thread.currentThread().getThreadGroup(); namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"; } @Override 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; } }
Executor的execute()方法
execute() 方法将Runnable实例加入pool中,并进行一些pool size计算和优先级处理
execute() 方法本身在Executor接口中定义,有多个实现类都定义了不同的execute()方法
如ThreadPoolExecutor类(cache,fiexed,single三种池子都是调用它)的execute方法如下:
public void execute(Runnable command) { if (command == null) throw new NullPointerException(); if (poolSize >= corePoolSize ||!addIfUnderCorePoolSize(command)) { if (runState == RUNNING &&workQueue.offer(command)) { if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command); } else if (!addIfUnderMaximumPoolSize(command)) reject(command); // is shutdown or saturated } }