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

最新推荐文章于 2024-09-30 15:31:39 发布
最新推荐文章于 2024-09-30 15:31:39 发布
阅读量1.7k 收藏
点赞数
分类专栏： JAVA开发学习 性能测试分析 性能测试

线程池对执行同步或异步的任务很重要。本文展示如何利用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
2
3
4
5
6
7
8
9
10
11
<!-- Spring 3 dependencies -->
< dependency >
     < groupId >org.springframework</ groupId >
     < artifactId >spring-core</ artifactId >
     < version >${spring.version}</ version >
</ dependency >
< dependency >
     < groupId >org.springframework</ groupId >
     < artifactId >spring-context</ artifactId >
     < version >${spring.version}</ version >
</ dependency >

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

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

第3步：创建任务类

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

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

第4步：创建TestRejectedExecutionHandler类

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

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

第5步：创建ITestThreadPoolExecutorService接口

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

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

第6步：创建TestThreadPoolExecutorService类

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

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

第7步： 创建IThreadPoolMonitorService接口

创建IThreadPoolMonitorService接口

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

第8步：创建ThreadPoolMonitorService类

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

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

第9步：创建Starter类

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

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

第10步：创建Application类

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

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

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

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

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

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

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

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

第13步：构建项目

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

第14步：运行工程

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

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

原文链接： dzone 翻译： ImportNew.com - 文 学敏
译文链接： http://www.importnew.com/14163.html
可口可乐的围脖
关注
专栏目录
spring实现线程池监控以及动态配置参数
github_lyrric的博客
03-11 512
spring实现线程池监控 动态配置参数 修改队列容量
线程池监控和动态配置
Moonxiyue的博客
06-15 1978
线程池是一种 “池化” 的线程使用模式，通过创建一定数量的线程，让这些线程处于就绪状态来提高系统响应速度，在线程使用完成后归还到线程池来达到重复利用的目标，从而降低系统资源的消耗。使用线程池，有如下优势为了能更好的控制多线程，JDK 提供了一套 框架，其本质就是一个线程池，它的核心成员如下。常用方法 常用方法如下避免使用Executors创建线程池根据阿里《Java开发手册》，要避免使用 创建线程池，推荐使用 创建线程池。Java 中，线程池的实现类是 ，其构造函数如下。 ：线程池核心线程数
代码组件 ---- Spring Boot 项目线程池监控
编码爱好者
09-22 918
需要对项目中的线程池指标进行监控检查。
【Springboot入门- Actuator监控-线程池】
最新发布
lixiaoyi01的博客
09-30 301
要在Spring Boot中监控线程池，可以利用Spring Boot Actuator的监控功能。
Spring Boot项目中线程池的动态监控
weixin_54542328的博客
10-25 2541
同时，也可以编写定制的监控逻辑，通过日志、监控系统或实时dashboard来展示监控数据。通过实时监控线程池和任务队列的状态，我们可以设置动态调整策略，当任务队列达到阈值时，自动增加线程池的大小，以便更快地处理积压的任务。在活动期间，系统的访问量激增，任务队列迅速增长，原有的线程池配置可能无法应对如此大的流量。考虑一个电商平台的Spring Boot应用，在特定的营销活动期间，会面临巨大的并发流量。这样，我们就可以根据日志中的信息，评估线程池的状态和动态调整策略的效果，进一步优化我们的调整策略和参数。
基于Spring Boot的线程池监控方案
weixin_38592881的博客
03-13 3665
前言 这篇是推动大家异步编程的思想的线程池的准备篇，要做好监控，让大家使用无后顾之忧，敬畏生产。 为什么需要对线程池进行监控 Java线程池作为最常使用到的并发工具，相信大家都不陌生，但是你真的确定使用对了吗？大名鼎鼎的阿里Java代码规范要求我们不使用 Executors来快速创建线程池，但是抛弃Executors，使用其它方式创建线程池就一定不会出现问题吗？本质上对于我们来说线程池本身的运行过程是一个黑盒，我们没办法了解线程池中的运行状态时，出现问题没有办法及时判断和预警。面对这种黑盒操作必须通过监控方
spring actuator 监控线程池
qq_39302650的博客
10-31 1311
spring actuator 监控线程池执行情况
springmvc+spring线程池处理http并发请求数据同步控制问题
03-27
4. 监控和调优：通过Spring Boot Actuator等监控工具，实时查看线程池状态，根据实际运行情况调整配置。 总结，使用Spring MVC和Spring线程池处理HTTP并发请求，能够有效提升系统的并发处理能力。同时，通过数据...
Spring Boot动态线程池与线程池监控的实现
线程池监控是指通过某种方式收集线程池运行时的各种状态信息，以监控线程池的健康状况和资源使用情况。在Spring Boot中，可以通过实现`ThreadPoolExecutor`的`afterExecute`方法或者使用定时任务定期查询线程池状态...
Spring Cloud 学习案例，服务发现、服务治理、链路追踪、服务监控等
11-03
这个学习案例将涵盖服务发现、服务治理、链路追踪和服务监控等多个核心概念。 **1. 服务发现** 服务发现是分布式系统中的关键组件，Spring Cloud 提供了 Netflix Eureka 作为服务注册与发现的工具。Eureka 由两部分...
腾讯二面：你们线程池是怎么做监控的？
Park33的博客
08-18 530
上面说到，线程池的采集历史运行数据在各个应用系统中，数据的存储、定期删除是否可以抽象出来，避免重复的工作​如果选择抽象数据存储，客户端节点与服务端之间的交互如下：客户端定时采集线程池历史运行数据，将数据打包好发送服务端服务端接收客户端上报的数据，进行数据入库持久化存储服务端定期删除或存档客户端线程池历史运行数据由服务端统一对外提供线程池运行图表的数据展示这里有个小问题，客户端如何打包发送给服务端？定时采集数据后直接上报是不是可行呢。...
Java线程池运行状态监控实现解析
08-25
主要介绍了Java线程池运行状态监控实现解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot 多任务并行+线程池处理的实现
08-27
主要介绍了SpringBoot 多任务并行+线程池处理的实现,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Springboot实现多线程及线程池监控
IT_world_的博客
12-09 3494
【代码】Springboot实现多线程及线程池监控。
线程池的配置和监控
Hi
03-23 2803
一.合理的配置线程池 要合理的配置线程池，首先得分析任务特性，可以从以下几个角度来分析： 1. 任务的性质：CPU密集型任务，IO密集型任务和混合型任务。 2. 任务的优先级：高，中和低。 3. 任务的执行时间：长，中和短。 4. 任务的依赖性：是否依赖其他系统资源，如数据库连接。 任务性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务配置尽可能小的线程，如配置Ncpu+1个
[开源项目]可观测、易使用的SpringBoot线程池
字母哥博客
08-08 1075
在开发spring boot应用服务的时候，难免会使用到异步任务及线程池。spring boot的线程池是可以自定义的，所以我们经常会在项目里面看到类似于下面这样的代码），方便集成到Spring Boot项目里面去。。需要说明的是：zimug-monitor-threadpool并未改变SpringBoot线程池的实现，只是在其基础上添加了初始化阶段的配置自动化加载，运行时的状态监控。所以任何有关Spring Boot线程池运行时性能的讨论，都与本文及其实现无关。...
线程池监控
LuckFairyLuckBaby的博客
08-07 1460
*** @Motto 让营地比你来时更干净/*** 自定义线程池} /*** 重写before executor方法，该方法每次任务执行前调用，在他内部调用一遍monitor方法，每当有任务执行的时候，输出一次线程池的情况，* @param t* @param rmonitor();} /*** 接着重写afterexecutor方法，该方法每次任务完成后调用，在它内部也调用一遍monitor方法，每当有任务完成的时候，输出一次线程池的情况，* @param r。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值