51CTO首页
AI.x社区
博客
学堂
精品班
直播训练营
企业培训
鸿蒙开发者社区
WOT技术大会
AIGC创新中国行
公众号矩阵
移动端
短视频免费课程课程排行直播课软考学堂
全部课程厂商认证IT技术2024年软考PMP项目管理软考资讯
在线学习
文章资源问答课堂专栏直播
51CTO
鸿蒙开发者社区
51CTO技术栈
51CTO官微
51CTO学堂
51CTO博客
CTO训练营
鸿蒙开发者社区订阅号
51CTO题库小程序
51CTO学堂APP
51CTO学堂企业版APP
鸿蒙开发者社区视频号
账号设置 退出

如何使用Spring开发和监控线程池服务

作者：文学敏
开发 后端
线程池对执行同步或异步的任务很重要。本文展示如何利用Spring开发并监控线程池服务。创建线程池的其他两种方法已讲解过。

线程池对执行同步或异步的任务很重要。本文展示如何利用Spring开发并监控线程池服务。创建线程池的其他两种方法已讲解过。

使用技术

  • JDK 1.6.0_21
  • Spring 3.0.5
  • Maven 3.0.2

第1步：创建Maven工程

下面是一个maven工程。（可以使用Maven或IDE的插件创建）。

第2步：添加依赖库

将Spring的依赖添加到Maven的pom.xml文件中。

  1. <!-- Spring 3 dependencies --> 
  2. <dependency> 
  3.     <groupId>org.springframework</groupId> 
  4.     <artifactId>spring-core</artifactId> 
  5.     <version>${spring.version}</version> 
  6. </dependency> 
  7. <dependency> 
  8.     <groupId>org.springframework</groupId> 
  9.     <artifactId>spring-context</artifactId> 
  10.     <version>${spring.version}</version> 
  11. </dependency> 

使用下面的插件创建可执行jar包。

  1. <plugin> 
  2.     <groupId>org.apache.maven.plugins</groupId> 
  3.     <artifactId>maven-shade-plugin</artifactId> 
  4.     <version>1.3.1</version> 
  5.     <executions> 
  6.         <execution> 
  7.             <phase>package</phase> 
  8.             <goals> 
  9.                 <goal>shade</goal> 
  10.             </goals> 
  11.             <configuration> 
  12.                 <transformers> 
  13.                     <transformer 
  14.                         implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> 
  15.                         <mainClass>com.otv.exe.Application</mainClass> 
  16.                     </transformer> 
  17.                     <transformer 
  18.                         implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer"> 
  19.                         <resource>META-INF/spring.handlers</resource> 
  20.                     </transformer> 
  21.                     <transformer 
  22.                         implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer"> 
  23.                         <resource>META-INF/spring.schemas</resource> 
  24.                     </transformer> 
  25.                 </transformers> 
  26.             </configuration> 
  27.         </execution> 
  28.     </executions> 
  29. </plugin> 

第3步：创建任务类

创建一个实现Runnable接口的新TestTask类。这个类表示要执行的任务。

  1. package com.otv.task; 
  2.   
  3. import org.apache.log4j.Logger; 
  4.   
  5. /** 
  6.  * @author onlinetechvision.com 
  7.  * @since 17 Oct 2011 
  8.  * @version 1.0.0 
  9.  * 
  10.  */ 
  11. public class TestTask implements Runnable { 
  12.   
  13.     private static Logger log = Logger.getLogger(TestTask.class); 
  14.     String taskName; 
  15.   
  16.     public TestTask() { 
  17.     } 
  18.   
  19.     public TestTask(String taskName) { 
  20.         this.taskName = taskName; 
  21.     } 
  22.   
  23.     public void run() { 
  24.         try { 
  25.             log.debug(this.taskName + " : is started."); 
  26.             Thread.sleep(10000); 
  27.             log.debug(this.taskName + " : is completed."); 
  28.         } catch (InterruptedException e) { 
  29.             log.error(this.taskName + " : is not completed!"); 
  30.             e.printStackTrace(); 
  31.         }        
  32.     } 
  33.   
  34.     @Override 
  35.     public String toString() { 
  36.         return (getTaskName()); 
  37.     } 
  38.   
  39.     public String getTaskName() { 
  40.         return taskName; 
  41.     } 
  42.   
  43.     public void setTaskName(String taskName) { 
  44.         this.taskName = taskName; 
  45.     } 
  46. } 

第4步：创建TestRejectedExecutionHandler类

TestRejectedExecutionHandler类实现了RejectedExecutionHandler接口。如果没有空闲线程并且队列超出限制，任务会被拒绝。这个类处理被拒绝的任务。

  1. package com.otv.handler; 
  2.   
  3. import java.util.concurrent.RejectedExecutionHandler; 
  4. import java.util.concurrent.ThreadPoolExecutor; 
  5.   
  6. import org.apache.log4j.Logger; 
  7.   
  8. /** 
  9.  * @author onlinetechvision.com 
  10.  * @since 17 Oct 2011 
  11.  * @version 1.0.0 
  12.  * 
  13.  */ 
  14. public class TestRejectedExecutionHandler implements RejectedExecutionHandler { 
  15.   
  16.     private static Logger log = Logger.getLogger(TestRejectedExecutionHandler.class); 
  17.   
  18.     public void rejectedExecution(Runnable runnable, ThreadPoolExecutor executor) { 
  19.         log.debug(runnable.toString() + " : has been rejected"); 
  20.     } 
  21. } 

第5步：创建ITestThreadPoolExecutorService接口

创建ITestThreadPoolExecutorService接口。（译者注：这个接口的主要功能是通过设置的参数创建一个线程池）

  1. package com.otv.srv; 
  2.   
  3. import java.util.concurrent.ThreadPoolExecutor; 
  4.   
  5. import com.otv.handler.TestRejectedExecutionHandler; 
  6.   
  7. /** 
  8.  * @author onlinetechvision.com 
  9.  * @since 17 Oct 2011 
  10.  * @version 1.0.0 
  11.  *  
  12.  */ 
  13. public interface ITestThreadPoolExecutorService { 
  14.   
  15.     public ThreadPoolExecutor createNewThreadPool(); 
  16.   
  17.     public int getCorePoolSize(); 
  18.   
  19.     public void setCorePoolSize(int corePoolSize); 
  20.   
  21.     public int getMaxPoolSize(); 
  22.   
  23.     public void setMaxPoolSize(int maximumPoolSize); 
  24.   
  25.     public long getKeepAliveTime(); 
  26.   
  27.     public void setKeepAliveTime(long keepAliveTime); 
  28.   
  29.     public int getQueueCapacity(); 
  30.   
  31.     public void setQueueCapacity(int queueCapacity); 
  32.   
  33.     public TestRejectedExecutionHandler getTestRejectedExecutionHandler(); 
  34.   
  35.     public void setTestRejectedExecutionHandler(TestRejectedExecutionHandler testRejectedExecutionHandler); 
  36.   
  37. } 

第6步：创建TestThreadPoolExecutorService类

TestThreadPoolExecutorService类实现了ITestThreadPoolExecutorService接口（上一步创建的接口）。这个类可以创建一个新的线程池。

  1. package com.otv.srv; 
  2.   
  3. import java.util.concurrent.ArrayBlockingQueue; 
  4. import java.util.concurrent.ThreadPoolExecutor; 
  5. import java.util.concurrent.TimeUnit; 
  6.   
  7. import com.otv.handler.TestRejectedExecutionHandler; 
  8.   
  9. /** 
  10.  * @author onlinetechvision.com 
  11.  * @since 17 Oct 2011 
  12.  * @version 1.0.0 
  13.  * 
  14.  */ 
  15. public class TestThreadPoolExecutorService implements ITestThreadPoolExecutorService { 
  16.   
  17.     private int  corePoolSize; 
  18.     private int  maxPoolSize;  
  19.     private long keepAliveTime; 
  20.     private int  queueCapacity; 
  21.     TestRejectedExecutionHandler testRejectedExecutionHandler; 
  22.   
  23.     public ThreadPoolExecutor createNewThreadPool() { 
  24.         ThreadPoolExecutor executor = new ThreadPoolExecutor(getCorePoolSize(),  
  25.                                                                 getMaxPoolSize(),  
  26.                                                                 getKeepAliveTime(),  
  27.                                                                 TimeUnit.SECONDS,  
  28.                                                                 new ArrayBlockingQueue(getQueueCapacity()),  
  29.                                                                 getTestRejectedExecutionHandler()); 
  30.         return executor; 
  31.     } 
  32.   
  33.     public int getCorePoolSize() { 
  34.         return corePoolSize; 
  35.     } 
  36.   
  37.     public void setCorePoolSize(int corePoolSize) { 
  38.         this.corePoolSize = corePoolSize; 
  39.     } 
  40.   
  41.     public int getMaxPoolSize() { 
  42.         return maxPoolSize; 
  43.     } 
  44.   
  45.     public void setMaxPoolSize(int maxPoolSize) { 
  46.         this.maxPoolSize = maxPoolSize; 
  47.     } 
  48.   
  49.     public long getKeepAliveTime() { 
  50.         return keepAliveTime; 
  51.     } 
  52.   
  53.     public void setKeepAliveTime(long keepAliveTime) { 
  54.         this.keepAliveTime = keepAliveTime; 
  55.     } 
  56.   
  57.     public int getQueueCapacity() { 
  58.         return queueCapacity; 
  59.     } 
  60.   
  61.     public void setQueueCapacity(int queueCapacity) { 
  62.         this.queueCapacity = queueCapacity; 
  63.     } 
  64.   
  65.     public TestRejectedExecutionHandler getTestRejectedExecutionHandler() { 
  66.         return testRejectedExecutionHandler; 
  67.     } 
  68.   
  69.     public void setTestRejectedExecutionHandler(TestRejectedExecutionHandler testRejectedExecutionHandler) { 
  70.         this.testRejectedExecutionHandler = testRejectedExecutionHandler; 
  71.     } 
  72. } 

第7步： 创建IThreadPoolMonitorService接口

创建IThreadPoolMonitorService接口

  1. package com.otv.monitor.srv; 
  2.   
  3. import java.util.concurrent.ThreadPoolExecutor; 
  4.   
  5. public interface IThreadPoolMonitorService extends Runnable { 
  6.   
  7.     public void monitorThreadPool(); 
  8.   
  9.     public ThreadPoolExecutor getExecutor(); 
  10.   
  11.     public void setExecutor(ThreadPoolExecutor executor); 
  12. } 

第8步：创建ThreadPoolMonitorService类

ThreadPoolMonitorService类实现了IThreadPoolMonitorService接口。这个类用来监控已创建的线程池。

  1. package com.otv.monitor.srv; 
  2.   
  3. import java.util.concurrent.ThreadPoolExecutor; 
  4. import org.apache.log4j.Logger; 
  5.   
  6. /** 
  7.  * @author onlinetechvision.com 
  8.  * @since 17 Oct 2011 
  9.  * @version 1.0.0 
  10.  * 
  11.  */ 
  12. public class ThreadPoolMonitorService implements IThreadPoolMonitorService { 
  13.   
  14.     private static Logger log = Logger.getLogger(ThreadPoolMonitorService.class); 
  15.     ThreadPoolExecutor executor; 
  16.     private long monitoringPeriod;  
  17.   
  18.     public void run() { 
  19.         try { 
  20.             while (true){ 
  21.                 monitorThreadPool(); 
  22.                 Thread.sleep(monitoringPeriod*1000); 
  23.             }  
  24.         } catch (Exception e) { 
  25.             log.error(e.getMessage()); 
  26.         } 
  27.     } 
  28.   
  29.     public void monitorThreadPool() { 
  30.         StringBuffer strBuff = new StringBuffer(); 
  31.         strBuff.append("CurrentPoolSize : ").append(executor.getPoolSize()); 
  32.         strBuff.append(" - CorePoolSize : ").append(executor.getCorePoolSize()); 
  33.         strBuff.append(" - MaximumPoolSize : ").append(executor.getMaximumPoolSize()); 
  34.         strBuff.append(" - ActiveTaskCount : ").append(executor.getActiveCount()); 
  35.         strBuff.append(" - CompletedTaskCount : ").append(executor.getCompletedTaskCount()); 
  36.         strBuff.append(" - TotalTaskCount : ").append(executor.getTaskCount()); 
  37.         strBuff.append(" - isTerminated : ").append(executor.isTerminated()); 
  38.   
  39.         log.debug(strBuff.toString()); 
  40.     } 
  41.   
  42.     public ThreadPoolExecutor getExecutor() { 
  43.         return executor; 
  44.     } 
  45.   
  46.     public void setExecutor(ThreadPoolExecutor executor) { 
  47.         this.executor = executor; 
  48.     }    
  49.   
  50.     public long getMonitoringPeriod() { 
  51.         return monitoringPeriod; 
  52.     } 
  53.   
  54.     public void setMonitoringPeriod(long monitoringPeriod) { 
  55.         this.monitoringPeriod = monitoringPeriod; 
  56.     } 
  57. } 

第9步：创建Starter类

（译者注：这个类内部维护了一个线程池服务（testThreadPoolExecutorService）和一个监控服务（threadPoolMonitorService），然后创建线程池、启动一个单独的线程执行监控服务、通过线程池执行任务）

  1. package com.otv.start; 
  2.   
  3. import java.util.concurrent.ThreadPoolExecutor; 
  4.   
  5. import org.apache.log4j.Logger; 
  6.   
  7. import com.otv.handler.TestRejectedExecutionHandler; 
  8. import com.otv.monitor.srv.IThreadPoolMonitorService; 
  9. import com.otv.monitor.srv.ThreadPoolMonitorService; 
  10. import com.otv.srv.ITestThreadPoolExecutorService; 
  11. import com.otv.srv.TestThreadPoolExecutorService; 
  12. import com.otv.task.TestTask; 
  13.   
  14. /** 
  15.  * @author onlinetechvision.com 
  16.  * @since 17 Oct 2011 
  17.  * @version 1.0.0 
  18.  * 
  19.  */ 
  20. public class Starter { 
  21.   
  22.     private static Logger log = Logger.getLogger(TestRejectedExecutionHandler.class); 
  23.   
  24.     IThreadPoolMonitorService threadPoolMonitorService; 
  25.     ITestThreadPoolExecutorService testThreadPoolExecutorService; 
  26.   
  27.     public void start() { 
  28.   
  29.         // A new thread pool is created... 
  30.         ThreadPoolExecutor executor = testThreadPoolExecutorService.createNewThreadPool(); 
  31.         executor.allowCoreThreadTimeOut(true); 
  32.   
  33.         // Created executor is set to ThreadPoolMonitorService... 
  34.         threadPoolMonitorService.setExecutor(executor); 
  35.   
  36.         // ThreadPoolMonitorService is started... 
  37.         Thread monitor = new Thread(threadPoolMonitorService); 
  38.         monitor.start(); 
  39.   
  40.         // New tasks are executed... 
  41.         for(int i=1;i&lt;10;i++) { 
  42.             executor.execute(new TestTask(&quot;Task&quot;+i)); 
  43.         } 
  44.   
  45.         try { 
  46.             Thread.sleep(40000); 
  47.         } catch (Exception e)   { 
  48.             log.error(e.getMessage()); 
  49.         } 
  50.   
  51.         for(int i=10;i&lt;19;i++) { 
  52.             executor.execute(new TestTask(&quot;Task&quot;+i)); 
  53.         } 
  54.   
  55.         // executor is shutdown... 
  56.         executor.shutdown(); 
  57.     }    
  58.   
  59.     public IThreadPoolMonitorService getThreadPoolMonitorService() { 
  60.         return threadPoolMonitorService; 
  61.     } 
  62.   
  63.     public void setThreadPoolMonitorService(IThreadPoolMonitorService threadPoolMonitorService) { 
  64.         this.threadPoolMonitorService = threadPoolMonitorService; 
  65.     } 
  66.   
  67.     public ITestThreadPoolExecutorService getTestThreadPoolExecutorService() { 
  68.         return testThreadPoolExecutorService; 
  69.     } 
  70.   
  71.     public void setTestThreadPoolExecutorService(ITestThreadPoolExecutorService testThreadPoolExecutorService) { 
  72.         this.testThreadPoolExecutorService = testThreadPoolExecutorService; 
  73.     } 
  74. } 

第10步：创建Application类

创建Application类。这个类运行应用程序。

  1. package com.otv.start; 
  2.   
  3. import org.springframework.context.ApplicationContext; 
  4. import org.springframework.context.support.ClassPathXmlApplicationContext; 
  5.   
  6. /** 
  7.  * @author onlinetechvision.com 
  8.  * @since 17 Oct 2011 
  9.  * @version 1.0.0 
  10.  * 
  11.  */ 
  12. public class Application { 
  13.   
  14.     public static void main(String[] args) { 
  15.        ApplicationContext context = new ClassPathXmlApplicationContext(&quot;applicationContext.xml&quot;); 
  16.        Starter starter = (Starter) context.getBean(&quot;Starter&quot;); 
  17.        starter.start(); 
  18.     } 
  19. } 

第11步：创建applicationContext.xml文件

（译者注：在Spring中注册了上面所创建的类，并提前设置了部分相应的参数，比如将监控服务的监控周期设为5）

  1. <beans xmlns="http://www.springframework.org/schema/beans" 
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  3.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
  4.   
  5. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
  6.   
  7.     <!-- Beans Declaration --> 
  8.     <bean id="TestTask" class="com.otv.task.TestTask"></bean> 
  9.     <bean id="ThreadPoolMonitorService" class="com.otv.monitor.srv.ThreadPoolMonitorService"> 
  10.         <property name="monitoringPeriod"  value="5" /> 
  11.     </bean> 
  12.     <bean id="TestRejectedExecutionHandler" class="com.otv.handler.TestRejectedExecutionHandler"></bean> 
  13.     <bean id="TestThreadPoolExecutorService" class="com.otv.srv.TestThreadPoolExecutorService"> 
  14.         <property name="corePoolSize"  value="1" /> 
  15.         <property name="maxPoolSize"   value="3" /> 
  16.         <property name="keepAliveTime" value="10" /> 
  17.         <property name="queueCapacity" value="3" /> 
  18.         <property name="testRejectedExecutionHandler" ref="TestRejectedExecutionHandler" /> 
  19.     </bean> 
  20.     <bean id="Starter" class="com.otv.start.Starter"> 
  21.         <property name="threadPoolMonitorService" ref="ThreadPoolMonitorService" /> 
  22.         <property name="testThreadPoolExecutorService" ref="TestThreadPoolExecutorService" /> 
  23.     </bean> 
  24. </beans> 

第12步：创建线程池的另一方法

Spring提供的ThreadPoolTaskExecutor类也可以创建线程池。

（译者注：上面通过我们自己创建的TestThreadPoolExecutorService类来设置线程池的各项参数并创建线程池，但实际上Spring也提供了功能类似的类，就是ThreadPoolTaskExecutor。所以也可以使用这种方式创建线程池）

  1. <bean id="threadPoolTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> 
  2.   <property name="corePoolSize"  value="1" /> 
  3.   <property name="maxPoolSize"   value="3" /> 
  4.   <property name="queueCapacity" value="3" /> 
  5. </bean> 
  6.   
  7. <bean id="testTaskExecutor" class="TestTaskExecutor"> 
  8.   <constructor-arg ref="threadPoolTaskExecutor" /> 
  9. </bean> 

第13步：构建项目

OTV_Spring_ThreadPool工程被build后，就会产生一个OTV_Spring_ThreadPool-0.0.1-SNAPSHOT.jar包。

第14步：运行工程

OTV_Spring_ThreadPool-0.0.1-SNAPSHOT.jar运行后，输出日志如下：

  1. 18.10.2011 20:08:48 DEBUG (TestRejectedExecutionHandler.java:19) - Task7 : has been rejected 
  2. 18.10.2011 20:08:48 DEBUG (TestRejectedExecutionHandler.java:19) - Task8 : has been rejected 
  3. 18.10.2011 20:08:48 DEBUG (TestRejectedExecutionHandler.java:19) - Task9 : has been rejected 
  4. 18.10.2011 20:08:48 DEBUG (TestTask.java:25) - Task1 : is started. 
  5. 18.10.2011 20:08:48 DEBUG (TestTask.java:25) - Task6 : is started. 
  6. 18.10.2011 20:08:48 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 2 - CompletedTaskCount : 0 - TotalTaskCount : 5 - isTerminated : false 
  7. 18.10.2011 20:08:48 DEBUG (TestTask.java:25) - Task5 : is started. 
  8. 18.10.2011 20:08:53 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 3 - CompletedTaskCount : 0 - TotalTaskCount : 6 - isTerminated : false 
  9. 18.10.2011 20:08:58 DEBUG (TestTask.java:27) - Task6 : is completed. 
  10. 18.10.2011 20:08:58 DEBUG (TestTask.java:27) - Task1 : is completed. 
  11. 18.10.2011 20:08:58 DEBUG (TestTask.java:25) - Task3 : is started. 
  12. 18.10.2011 20:08:58 DEBUG (TestTask.java:25) - Task2 : is started. 
  13. 18.10.2011 20:08:58 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 3 - CompletedTaskCount : 2 - TotalTaskCount : 6 - isTerminated : false 
  14. 18.10.2011 20:08:58 DEBUG (TestTask.java:27) - Task5 : is completed. 
  15. 18.10.2011 20:08:58 DEBUG (TestTask.java:25) - Task4 : is started. 
  16. 18.10.2011 20:09:03 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 3 - CompletedTaskCount : 3 - TotalTaskCount : 6 - isTerminated : false 
  17. 18.10.2011 20:09:08 DEBUG (TestTask.java:27) - Task2 : is completed. 
  18. 18.10.2011 20:09:08 DEBUG (TestTask.java:27) - Task3 : is completed. 
  19. 18.10.2011 20:09:08 DEBUG (TestTask.java:27) - Task4 : is completed. 
  20. 18.10.2011 20:09:08 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 0 - CompletedTaskCount : 6 - TotalTaskCount : 6 - isTerminated : false 
  21. 18.10.2011 20:09:13 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 0 - CompletedTaskCount : 6 - TotalTaskCount : 6 - isTerminated : false 
  22. 18.10.2011 20:09:18 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 0 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 0 - CompletedTaskCount : 6 - TotalTaskCount : 6 - isTerminated : false 
  23. 18.10.2011 20:09:23 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 0 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 0 - CompletedTaskCount : 6 - TotalTaskCount : 6 - isTerminated : false 
  24. 18.10.2011 20:09:28 DEBUG (TestTask.java:25) - Task10 : is started. 
  25. 18.10.2011 20:09:28 DEBUG (TestRejectedExecutionHandler.java:19) - Task16 : has been rejected 
  26. 18.10.2011 20:09:28 DEBUG (TestRejectedExecutionHandler.java:19) - Task17 : has been rejected 
  27. 18.10.2011 20:09:28 DEBUG (TestRejectedExecutionHandler.java:19) - Task18 : has been rejected 
  28. 18.10.2011 20:09:28 DEBUG (TestTask.java:25) - Task14 : is started. 
  29. 18.10.2011 20:09:28 DEBUG (TestTask.java:25) - Task15 : is started. 
  30. 18.10.2011 20:09:28 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 3 - CompletedTaskCount : 6 - TotalTaskCount : 12 - isTerminated : false 
  31. 18.10.2011 20:09:33 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 3 - CompletedTaskCount : 6 - TotalTaskCount : 12 - isTerminated : false 
  32. 18.10.2011 20:09:38 DEBUG (TestTask.java:27) - Task10 : is completed. 
  33. 18.10.2011 20:09:38 DEBUG (TestTask.java:25) - Task11 : is started. 
  34. 18.10.2011 20:09:38 DEBUG (TestTask.java:27) - Task14 : is completed. 
  35. 18.10.2011 20:09:38 DEBUG (TestTask.java:27) - Task15 : is completed. 
  36. 18.10.2011 20:09:38 DEBUG (TestTask.java:25) - Task12 : is started. 
  37. 18.10.2011 20:09:38 DEBUG (TestTask.java:25) - Task13 : is started. 
  38. 18.10.2011 20:09:38 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 3 - CompletedTaskCount : 9 - TotalTaskCount : 12 - isTerminated : false 
  39. 18.10.2011 20:09:43 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 3 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 3 - CompletedTaskCount : 9 - TotalTaskCount : 12 - isTerminated : false 
  40. 18.10.2011 20:09:48 DEBUG (TestTask.java:27) - Task11 : is completed. 
  41. 18.10.2011 20:09:48 DEBUG (TestTask.java:27) - Task13 : is completed. 
  42. 18.10.2011 20:09:48 DEBUG (TestTask.java:27) - Task12 : is completed. 
  43. 18.10.2011 20:09:48 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 0 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 0 - CompletedTaskCount : 12 - TotalTaskCount : 12 - isTerminated : true 
  44. 18.10.2011 20:09:53 DEBUG (ThreadPoolMonitorService.java:39) - CurrentPoolSize : 0 - CorePoolSize : 1 - MaximumPoolSize : 3 - ActiveTaskCount : 0 - CompletedTaskCount : 12 - TotalTaskCount : 12 - isTerminated : true 

第15步：下载

OTV_Spring_ThreadPool

原文链接：dzone 翻译： ImportNew.com - 文 学敏

译文链接： http://www.importnew.com/14163.html

责任编辑：张伟 来源： ImportNew
Spring
相关推荐
Java的多线程和线程池的使用
多线程大大提高程序运行效率，我们在开发过程中经常会开启一个线程来执行一些费时的任务。开启一个线程有4种方式，在下面的文章我将详细的去讲解。

2021-09-11 15:26:23

Java多线程线程池
如何使用Builder模式构建线程池
Builder设计模式也叫做构建者模式或者建造者模式，名字只是一种叫法，当聊起三种名称的时候知道是怎么回事就行.

2021-02-06 14:02:55

线程池Builder模式
使用VMControl实现服务器池Workload的管理和监控
VMControl提供了一系列的PowerVM虚拟化环境的管理和监控功能，用户可以可以通过Director的图形界面（GUI）使用这些功能，但对一些习惯于命令行操作的高级Power系统管理员来说，使用命令行操作可以节约界面切换等待时间。本文将通过实例对一些常用的VMControl命令行进行介绍。

2012-10-15 15:53:59

线程池如何监控，才能帮助开发者快速定位线上错误？
不论线程池是否由Spring管理，采集的方式大致相同。一种从Spring容器取，一种是创建好线程池后放到一个自定义容器

2021-12-26 19:05:23

监控定位开发者
你知道如何使用Java线程池吗？
Java中的线程池是通过ThreadPoolExecutor类来实现的，它提供了一系列的方法来创建、提交、执行和关闭线程池，同时还可以设置线程池的参数、任务队列等。

2023-06-08 07:48:03

Java线程池
使用 Spring Boot 如何快速进行 Web 微服务开发？
SpringBoot已成为当今最流行的微服务开发框架，本文是如何使用SpringBoot快速开始Web微服务开发的指南，我们将创建一个可运行的包含内嵌Web容器（默认使用的是Tomcat）的可运行jar包。

2018-05-04 15:27:22

Spring Boo Web开发
Java 5线程池使用
线程池为线程生命周期开销问题和资源不足问题提供了解决方案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上。其好处是，因为在请求到达时线程已经存在，所以无意中也消除了线程创建所带来的延迟。

2012-02-29 13:26:20

Java
线程池的使用场景和代码实现！
好了简单说了一下，后面的哪些什么内存池、连接池，后期复习都再给大家分享吧，今天我们的主题是线程池。

2021-06-06 23:40:53

线程池使用场景
使用Prometheus和Grafana监控Spring Boot应用
本文介绍两个开源工具：Grafana和Prometheus。Prometheus以时间序列格式收集和存储指标数据，而Grafana使用Prometheus作为数据源，在仪表板上可视化这些数据。

2023-12-27 18:05:13

面试突击：如何使用线程池执行定时任务？
scheduleWithFixedDelay方法的使用和scheduleAtFixedRate类似，但执行效果完全不同，这个很容易理解如果效果一样就不用创建两个方法了。

2022-03-28 08:31:29

线程池定时任务
Spring Boot服务监控(Prometheus)
Prometheus是什么，一款开源的优秀的时间序列数据库监控软件。收集各项指标，用于监控系统状态。提供强大的PromQL查询语句，满足各种个性化查询需求。

2022-05-18 08:32:05

服务监控Prometheus开源
如何使用Nagios监控oracle服务器
如何使用Nagios监控oracle服务器：Nagios是一个监视系统运行状态和网络信息的监视系统。Nagios能监视所指定的本地或远程主机以及服务，同时提供异常通功能等。本文讲述的是如何使用Nagios监控oracle服务器。

2011-03-23 15:13:08

Nagios监控oracle
Spring Boot使用@Async实现异步调用：自定义线程池
本文中的例子我们可以在之前的例子基础上修改，也可以创建一个全新的SpringBoot项目来尝试。

2018-06-21 14:46:03

Spring Boot异步调用
线程池原理详解及如何用C语言实现线程池
线程池是一种多线程处理形式，大多用于高并发服务器上，它能合理有效的利用高并发服务器上的线程资源;线程与进程用于处理各项分支子功能，我们通常的操作是：接收消息消息分类线程创建传递消息到子线程线程分离在子线程中执行任务任务结束退出。

2020-03-05 15:34:16

线程池C语言局域网
如何手写一个线程池？
按需创建线程，不要一开始就创建「corePoolSize」个线程，而是在调用者提交任务的过程中逐渐创建出来，最后创建了「corePoolSize」个就不再创建了。

2022-03-09 09:43:01

工具类线程项目
iPhone操作队列和Java线程池
本文介绍的是iPhone操作队列和Java线程池，主要介绍的是如何管理多线程对共享数据的访问以及防止线程间的死锁问题是个很重要的话题，来看内容。

2011-07-25 15:17:10

iPhone 操作队列 Java
C#线程：线程池和文件下载服务器
本文继续C线程系列讲座之三，即线程池和文件下载服务器。

2009-08-04 17:18:02

C#线程
线程池是如何重复利用空闲线程的？
在Java开发中，经常需要创建线程去执行一些任务，实现起来也非常方便，但如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率。

2021-06-24 08:02:35

线程池Java代码
如何使用Elasticsearch和cAdvisor监控Docker容器
在Dockernetwork特性出来以前，你可以使用Dockerlink特性实现容器互相发现、安全通信。而在network特性出来以后，你还可以使用link，但是当容器处于默认桥接网络或用户自定义网络时，它们的表现是不一样的。现在创建overlay网络，名称为monitoring。

2016-10-08 15:42:02

ElasticsearcAdvisorDocke
使用Spring Boot和Docker构建微服务
这个分步指南帮助全栈开发者使用SpringBoot在微服务中构建组件，并在Docker中使用它们。

2022-10-10 08:00:00

微服务Spring Boo容器
点赞
收藏

51CTO技术栈公众号

业务
速览
在线客服