ExecutorService与Executors例子的简单剖析

对于多线程有了一点了解之后,那么来看看java.lang.concurrent包下面的一些东西。在此之前,我们运行一个线程都是显式调用了Thread的start()方法。我们用concurrent下面的类来实现一下线程的运行,而且这将成为以后常用的方法或者实现思路。 

        看一个简单的例子: 

  1. public class CacheThreadPool {  
  2.     public static void main(String[] args) {  
  3.         ExecutorService exec=Executors.newCachedThreadPool();  
  4.         for(int i=0;i<5;i++)  
  5.             exec.execute(new LiftOff());  
  6.         exec.shutdown();//并不是终止线程的运行,而是禁止在这个Executor中添加新的任务  
  7.     }  
  8. }  


        这个例子其实很容易看懂,ExecutorService中有一个execute方法,这个方法的参数是Runnable类型。也就是说,将一个实现了Runnable类型的类的实例作为参数传入execute方法并执行,那么线程就相应的执行了。 

        一、ExecutorService 
        先看看ExecutorService,这是一个接口,简单的列一下这个接口: 

  1. public interface ExecutorService extends Executor {  
  2.   
  3.     void shutdown();  
  4.   
  5.     List<Runnable> shutdownNow();  
  6.   
  7.     boolean isShutdown();  
  8.   
  9.     boolean isTerminated();  
  10.   
  11.     boolean awaitTermination(long timeout, TimeUnit unit)  
  12.   
  13.     <T> Future<T> submit(Callable<T> task);  
  14.   
  15.     <T> Future<T> submit(Runnable task, T result);  
  16.   
  17.     Future<?> submit(Runnable task);  
  18.   
  19.     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)  
  20.   
  21.     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)  
  22.   
  23.     <T> T invokeAny(Collection<? extends Callable<T>> tasks)  
  24.   
  25.     <T> T invokeAny(Collection<? extends Callable<T>> tasks,  
  26.                     long timeout, TimeUnit unit)  
  27. }  


        ExecuteService继承了Executor,Executor也是一个接口,里面只有一个方法: 

  1. void execute(Runnable command)  



        二、Executors 
        Executors是一个类,直接援引JDK文档的说明来说一下这个类的作用: 
       

    •         Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package. This class supports the following kinds of methods: 

 

  •        
  • Methods that create and return an ExecutorService set up with commonly useful configuration settings.       
  • Methods that create and return a ScheduledExecutorService set up with commonly useful configuration settings.       
  • Methods that create and return a "wrapped" ExecutorService, that disables reconfiguration by making implementation-specific methods inaccessible.       
  • Methods that create and return a ThreadFactory that sets newly created threads to a known state.       
  • Methods that create and return a Callable out of other closure-like forms, so they can be used in execution methods requiring Callable.       


        在上面的例子中,我们用到了newCachedThreadPool()方法。看一下这个方法: 

  1. public static ExecutorService newCachedThreadPool() {  
  2.         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  
  3.                                       60L, TimeUnit.SECONDS,  
  4.                                       new SynchronousQueue<Runnable>());  
  5.     }  


        在源码中我们可以知道两点,1、这个方法返回类型是ExecutorService;2、此方法返回值实际是另一个类的实例。看一下这个类的信息: 

  1. public class ThreadPoolExecutor extends AbstractExecutorService {  
  2.     ..........  
  3.     private final BlockingQueue<Runnable> workQueue;//这个变量在下面会提到  
  4.     ..........  
  5. }  


        ThreadPoolExecutor继承了AbstractExecutorService,而AbstractExecutorService又实现了ExecutorService接口。所以,根据多态,ThreadPoolExecutor可以看作是ExecutorService类型。 

        线程执行的最关键的一步是执行了executor方法,根据java的动态绑定,实际执行的是ThreadPoolExecutor所实现的executor方法。看看源码: 

  1. public class ThreadPoolExecutor extends AbstractExecutorService {  
  2.     ..........  
  3.     public void execute(Runnable command) {  
  4.         if (command == null)  
  5.             throw new NullPointerException();  
  6.         if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {  
  7.             if (runState == RUNNING && workQueue.offer(command)) {  
  8.                 if (runState != RUNNING || poolSize == 0)  
  9.                     ensureQueuedTaskHandled(command);  
  10.             }  
  11.             else if (!addIfUnderMaximumPoolSize(command))  
  12.                 reject(command); // is shutdown or saturated  
  13.         }  
  14.     }  
  15.     ..........  
  16. }  


        根据程序正常执行的路线来看,这个方法中比较重要的两个地方分别是: 
        1、workQueue.offer(command) 
        workQueue在上面提到过,是BlockingQueue<Runnable>类型的变量,这条语句就是将Runnable类型的实例加入到队列中。 
        2、ensureQueuedTaskHandled(command) 
        这个是线程执行的关键语句。看看它的源码: 

  1. public class ThreadPoolExecutor extends AbstractExecutorService {  
  2.     ..........  
  3.     private void ensureQueuedTaskHandled(Runnable command) {  
  4.         final ReentrantLock mainLock = this.mainLock;  
  5.         mainLock.lock();  
  6.         boolean reject = false;  
  7.         Thread t = null;  
  8.         try {  
  9.             int state = runState;  
  10.             if (state != RUNNING && workQueue.remove(command))  
  11.                 reject = true;  
  12.             else if (state < STOP &&  
  13.                      poolSize < Math.max(corePoolSize, 1) &&  
  14.                      !workQueue.isEmpty())  
  15.                 t = addThread(null);  
  16.         } finally {  
  17.             mainLock.unlock();  
  18.         }  
  19.         if (reject)  
  20.             reject(command);  
  21.         else if (t != null)  
  22.             t.start();  
  23.     }  
  24.     ..........  
  25. }  


        在这里我们就可以看到最终执行了t.start()方法来运行线程。在这之前的重点是t=addThread(null)方法,看看addThread方法的源码: 

  1. public class ThreadPoolExecutor extends AbstractExecutorService {  
  2.     ..........  
  3.     private Thread addThread(Runnable firstTask) {  
  4.         Worker w = new Worker(firstTask);  
  5.         Thread t = threadFactory.newThread(w);  
  6.         if (t != null) {  
  7.             w.thread = t;  
  8.             workers.add(w);  
  9.             int nt = ++poolSize;  
  10.             if (nt > largestPoolSize)  
  11.                 largestPoolSize = nt;  
  12.         }  
  13.         return t;  
  14.     }  
  15.     ..........  
  16. }  


        这里两个重点,很明显: 
        1、Worker w = new Worker(firstTask) 
        2、Thread t = threadFactory.newThread(w) 
        先看Worker是个什么结构: 

  1. public class ThreadPoolExecutor extends AbstractExecutorService {  
  2.     ..........  
  3.     private final class Worker implements Runnable {  
  4.         ..........  
  5.         Worker(Runnable firstTask) {  
  6.             this.firstTask = firstTask;  
  7.         }  
  8.   
  9.         private Runnable firstTask;  
  10.         ..........  
  11.   
  12.         public void run() {  
  13.             try {  
  14.                 Runnable task = firstTask;  
  15.                 firstTask = null;  
  16.                 while (task != null || (task = getTask()) != null) {  
  17.                     runTask(task);  
  18.                     task = null;  
  19.                 }  
  20.             } finally {  
  21.                 workerDone(this);  
  22.             }  
  23.         }  
  24.     }  
  25.   
  26.     Runnable getTask() {  
  27.         for (;;) {  
  28.             try {  
  29.                 int state = runState;  
  30.                 if (state > SHUTDOWN)  
  31.                     return null;  
  32.                 Runnable r;  
  33.                 if (state == SHUTDOWN)  // Help drain queue  
  34.                     r = workQueue.poll();  
  35.                 else if (poolSize > corePoolSize || allowCoreThreadTimeOut)  
  36.                     r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);  
  37.                 else  
  38.                     r = workQueue.take();  
  39.                 if (r != null)  
  40.                     return r;  
  41.                 if (workerCanExit()) {  
  42.                     if (runState >= SHUTDOWN) // Wake up others  
  43.                         interruptIdleWorkers();  
  44.                     return null;  
  45.                 }  
  46.                 // Else retry  
  47.             } catch (InterruptedException ie) {  
  48.                 // On interruption, re-check runState  
  49.             }  
  50.         }  
  51.     }  
  52.     }  
  53.     ..........  
  54. }  


        Worker是一个内部类。根据之前可以知道,传入addThread的参数是null,也就是说Work中firstTask为null。
        在看看newThread是一个什么方法: 

  1. public class Executors {  
  2.     ..........  
  3.     static class DefaultThreadFactory implements ThreadFactory {  
  4.         ..........  
  5.         public Thread newThread(Runnable r) {  
  6.             Thread t = new Thread(group, r,  
  7.                                   namePrefix + threadNumber.getAndIncrement(),  
  8.                                   0);  
  9.             if (t.isDaemon())  
  10.                 t.setDaemon(false);  
  11.             if (t.getPriority() != Thread.NORM_PRIORITY)  
  12.                 t.setPriority(Thread.NORM_PRIORITY);  
  13.             return t;  
  14.         }  
  15.         ..........  
  16.     }  
  17.     ..........  
  18. }  


        通过源码可以得知threadFactory的实际类型是DefaultThreadFactory,而DefaultThreadFactory是Executors的一个嵌套内部类。 

        之前我们提到了t.start()这个方法执行了线程。那么现在从头顺一下,看看到底是执行了谁的run方法。首先知道,t=addThread(null),而addThread内部执行了下面三步,Worker w = new Worker(null);Thread t = threadFactory.newThread(w);return t;这里两个t是一致的。 
        从这里可以看出,t.start()实际上执行的是Worker内部的run方法。run()内部会在if条件里面使用“短路”:判断firstTask是否为null,若不是null则直接执行firstTask的run方法;如果是null,则调用getTask()方法来获取Runnable类型实例。从哪里获取呢?workQueue!在execute方法中,执行ensureQueuedTaskHandled(command)之前就已经把Runnable类型实例放入到workQueue中了,所以这里可以从workQueue中获取到。

<think>首先,用户的问题是关于Java中的ExecutorService,具体是重新调用Executors.newSingleThreadExecutor()创建新实例时,是否需要关闭或释放之前的实例。 从系统级指令中,我需要: - 所有行内数学表达式使用$...$格式,但用户的问题是关于Java代码的,没有数学表达式,所以可能不需要。 - 独立公式使用$$...$$格式,但这里没有公式。 - LaTeX语法正确:同样,没有数学内容。 - 使用中文回答。 - 生成相关问题。 - 回答中引用的段落末尾自然地添加引用标识,例如[^1]。 用户可见层: - 回答结构清晰,帮助用户逐步解决问题。 - 保证回答真实可靠。 参考站内引用: - 引用[1]: 关于newSingleThreadExecutor()的使用和关闭。 - 引用[2]: newSingleThreadExecutor()的实现细节。 - 引用[3]: Executors是工厂类,返回ThreadPoolExecutor实例,需要关闭。 - 引用[4]: Executors工具类提供各种线程池工厂方法。 - 引用[5]: newSingleThreadExecutor()方法的使用示例。 用户的核心问题是:在重新创建ExecutorService实例之前,是否需要关闭之前的实例。 关键点: - ExecutorService实例如果不关闭,会导致资源泄漏,比如线程不会被回收,可能造成内存泄漏或系统资源耗尽。 - 在Java中,ExecutorService应该在使用完毕后显式关闭,通过调用shutdown()或shutdownNow()方法。 - 重新创建新实例时,如果之前的实例没有被关闭,它可能仍然在运行,占用资源。 因此,答案是:是的,在重新调用Executors.newSingleThreadExecutor()创建新实例之前,应该关闭之前的ExecutorService实例。 理由: - 每个ExecutorService实例管理自己的线程池。newSingleThreadExecutor()创建一个只有一个线程的线程池。 - 如果不关闭,线程会继续存在,等待任务,这可能导致资源浪费。 - 关闭ExecutorService释放资源,允许JVM回收线程。 从引用中支持: - 引用[1]: "executorService.shutdown(); // 当不再提交任务时,应关闭ExecutorService" – 这强调了关闭的重要性。 - 引用[2]: 描述了newSingleThreadExecutor()的实现,使用ThreadPoolExecutor,这需要管理生命周期。 - 引用[3]: "executorService.shutdown();" – 在示例中显示了关闭。 - 引用[5]: 在示例中,有shutdown()和shutdownNow()的使用。 回答结构: 1. **明确回答用户问题**:直接回答是或否,并解释。 2. **解释原因**:为什么需要关闭,包括资源管理和潜在问题。 3. **提供示例或最佳实践**:如何正确关闭。 4. **生成相关问题**:在最后添加相关问题部分。 使用中文回答。 生成相关问题: - 基于主题,如ExecutorService的使用、关闭方法、资源管理等。 相关问题例子: 1. 如何正确关闭ExecutorService? 2. 如果不关闭ExecutorService会有什么后果? 3. newSingleThreadExecutor()其他线程池的区别? 4. ExecutorService的生命周期管理最佳实践? 确保回答真实可靠:基于Java文档和常见实践。 最终回答大纲: - 开头:直接回答问题。 - 主体:解释原因,引用支持内容。 - 结尾:总结并生成相关问题。</think>### 回答:在重新创建ExecutorService实例之前是否需要关闭之前的实例 在Java中,当您重新调用`Executors.newSingleThreadExecutor()`创建新的ExecutorService实例时,**强烈建议在创建新实例之前关闭或释放之前的ExecutorService实例**。如果不这样做,可能会导致资源泄漏、线程无法回收,甚至系统资源耗尽等问题。下面我将逐步解释原因、最佳实践和示例,帮助您理解如何正确管理ExecutorService的生命周期。 #### 1. **为什么需要关闭之前的ExecutorService实例?** - **资源管理**:每个ExecutorService实例(包括`newSingleThreadExecutor()`创建的)都管理一个线程池。如果不显式关闭,线程会一直存在,等待新任务提交,即使不再使用。这会导致内存泄漏和系统资源(如线程)无法被JVM回收[^2][^3]。 - **潜在风险**:如果频繁重新创建ExecutorService而不关闭旧实例,线程数量会累积,可能导致应用程序性能下降或崩溃。例如,`newSingleThreadExecutor()`创建的线程池只有一个核心线程,但如果不关闭,该线程会无限期存活[^1][^5]。 - **最佳实践**:Java官方文档和常见编程规范都强调,ExecutorService应在不再提交任务时立即关闭。这通过调用`shutdown()`或`shutdownNow()`方法实现,以确保优雅终止[^1][^3][^5]。 从引用内容看,`Executors.newSingleThreadExecutor()`返回的是`ThreadPoolExecutor`实例(通过`FinalizableDelegatedExecutorService`包装),其内部使用一个线程和一个无界队列。如果不关闭,队列中的任务或空闲线程将持续占用资源[^2][^4]。 #### 2. **如何正确关闭ExecutorService?** 在创建新实例前,应遵循以下步骤关闭旧实例: - 调用`shutdown()`方法:这会停止接受新任务,但允许已提交任务完成。 - 使用`awaitTermination()`:等待一段时间让任务结束,避免强制中断。 - 必要时调用`shutdownNow()`:如果任务未及时结束,强制中断所有线程。 - 在`finally`块中处理:确保异常时也能释放资源。 示例代码(基于引用[1]和[5]修改): ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class ExecutorExample { public static void main(String[] args) { // 第一次创建ExecutorService实例 ExecutorService firstExecutor = Executors.newSingleThreadExecutor(); firstExecutor.execute(() -> System.out.println("任务执行中...")); // 关闭第一个实例(在创建新实例前) firstExecutor.shutdown(); // 停止接受新任务 try { // 等待最多5秒让任务结束 if (!firstExecutor.awaitTermination(5, TimeUnit.SECONDS)) { firstExecutor.shutdownNow(); // 强制终止未完成任务 } } catch (InterruptedException e) { firstExecutor.shutdownNow(); // 处理中断异常 Thread.currentThread().interrupt(); } // 现在安全地创建新实例 ExecutorService newExecutor = Executors.newSingleThreadExecutor(); newExecutor.execute(() -> System.out.println("新任务执行中...")); newExecutor.shutdown(); // 使用后同样关闭新实例 } } ``` - **关键点**:在重新调用`Executors.newSingleThreadExecutor()`前,通过`shutdown()`和`awaitTermination()`确保旧实例完全终止。如果不关闭,直接创建新实例,旧线程可能仍在后台运行[^1][^5]。 #### 3. **不关闭的后果** - **资源泄漏**:线程未被回收,可能导致内存溢出(例如,`OutOfMemoryError`在长期运行的应用中)。 - **不可预测行为**:多个未关闭的ExecutorService实例可能竞争资源,导致任务执行混乱。 - 根据引用[3],ExecutorService是重量级对象,JVM不会自动回收它,必须显式管理生命周期[^3][^4]。 #### 总结 在Java中,每次重新调用`Executors.newSingleThreadExecutor()`创建新ExecutorService实例前,都必须关闭之前的实例。这是一种良好的编程习惯,能避免资源泄漏和性能问题。始终在`finally`块或使用try-with-resources(如果支持)中调用`shutdown()`方法。如果您在代码中遇到具体问题,可以提供更多细节,我可以进一步分析。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值