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

最新推荐文章于 2024-04-21 16:47:48 发布
最新推荐文章于 2024-04-21 16:47:48 发布
阅读量1.6k 收藏
点赞数
分类专栏： 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
可口可乐的围脖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring实现线程池监控以及动态配置参数
github_lyrric的博客
03-11 375
spring实现线程池监控 动态配置参数 修改队列容量
Java线程池运行状态监控实现解析
08-25
主要介绍了Java线程池运行状态监控实现解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
代码组件 ---- Spring Boot 项目线程池监控
编码爱好者
09-22 823
需要对项目中的线程池指标进行监控检查。
项目实战 ｜ 如何监控Java线程池
最新发布
weixin_46228563的博客
04-21 312
线程池提交了 100000 个任务，但同时只有 50 个线程在执行工作，我们每陋 3 秒来获取当前线程池的运行状态。活动线程数和总线程数是不变的，排队中的线程数和执行完成的线程数不断在变化，直到所有任务执行完毕。能实时获取线程池的当前活动线程数、正在排队中的任务数、已经执行完成的线程数、总任务数等。总任务数 = 排队任务数 + 活动线程数 + 执行完成的线程数。下面给出一个线程池使用示例，及教你获取线程池状态。
spring actuator 监控线程池
qq_39302650的博客
10-31 1182
spring actuator 监控线程池执行情况
基于Spring Boot的线程池监控方案
weixin_38592881的博客
03-13 3550
前言 这篇是推动大家异步编程的思想的线程池的准备篇，要做好监控，让大家使用无后顾之忧，敬畏生产。 为什么需要对线程池进行监控 Java线程池作为最常使用到的并发工具，相信大家都不陌生，但是你真的确定使用对了吗？大名鼎鼎的阿里Java代码规范要求我们不使用 Executors来快速创建线程池，但是抛弃Executors，使用其它方式创建线程池就一定不会出现问题吗？本质上对于我们来说线程池本身的运行过程是一个黑盒，我们没办法了解线程池中的运行状态时，出现问题没有办法及时判断和预警。面对这种黑盒操作必须通过监控方
04Hystrix Dashboard：断路器执行监控1
08-04
Hystrix Dashboard是Spring Cloud生态系统中的一个重要工具，用于实时监控HystrixCommand方法的执行状况。...正确配置和使用Hystrix Dashboard，可以极大地帮助开发团队预防和解决服务故障，提升整体架构的可靠性。
spring boot内置jetty
12-07
spring boot内置jetty开发，附带一些基础小功能，比如上传下载文件，走马灯，图片预览等等。
spring分布式任务调度
08-19
11、状态监控：支持实时监控任务进度； 12、Rolling执行日志：支持在线查看调度结果，并且支持以Rolling方式实时查看执行器输出的完整的执行日志； 13、GLUE：提供Web IDE，支持在线开发任务逻辑代码，动态发布，...
java开发日常总结.docx
11-20
- **性能分析**：理解CPU和内存瓶颈，使用JProfiler等工具进行性能监控。 - **多线程**：Java的并发编程模型包括线程池、同步机制（synchronized、Locks）和并发容器。 8. 持续集成与部署 - **CI/CD工具**：如...
XXL-JOB调度系统学习、调度流程、spring生命周期
07-23
整个架构设计考虑到了多线程和线程池的使用，以优化任务调度的效率。通过设计模式，比如工厂模式、策略模式等，XXL-JOB提供了灵活的扩展性，可以根据需求添加新的任务类型或调度策略。此外，通过日志管理和报警机制...
spring boot 监控处理方案实例详解
08-27
主要介绍了spring boot 监控处理方案的相关资料,非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
腾讯二面：你们线程池是怎么做监控的？
m0_67505824的博客
03-31 107
大部分情况下，线程池的运行情况对于使用者来说是个黑盒 运行情况不可知，会导致 生产出现事故问题排查困难，以及线程池参数难以定义 文章围绕线程池监控展开，讨论 线程池如何监控、监控的指标以及监控数据的存储展示 如何监控运行数据 设想一下，如果想监控线程池的运行数据，你会怎么操作？这里提供两种常规思路 线程池运行时埋点，每一次运行任务都进行统计 定时获取线程池的运行数据 这里我推荐第二种，因为线程池的监控 API 会通过 获取主锁来控制结果的相对准确性，性能相对较差，后面会详细说明 为什么
Springboot实现多线程及线程池监控
IT_world_的博客
12-09 3332
【代码】Springboot实现多线程及线程池监控。
线程池监控
LuckFairyLuckBaby的博客
08-07 1106
*** @Motto 让营地比你来时更干净/*** 自定义线程池} /*** 重写before executor方法，该方法每次任务执行前调用，在他内部调用一遍monitor方法，每当有任务执行的时候，输出一次线程池的情况，* @param t* @param rmonitor();} /*** 接着重写afterexecutor方法，该方法每次任务完成后调用，在它内部也调用一遍monitor方法，每当有任务完成的时候，输出一次线程池的情况，* @param r。
线程池的配置和监控
Hi
03-23 2759
一.合理的配置线程池 要合理的配置线程池，首先得分析任务特性，可以从以下几个角度来分析： 1. 任务的性质：CPU密集型任务，IO密集型任务和混合型任务。 2. 任务的优先级：高，中和低。 3. 任务的执行时间：长，中和短。 4. 任务的依赖性：是否依赖其他系统资源，如数据库连接。 任务性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务配置尽可能小的线程，如配置Ncpu+1个
SpringBoot生产监控
Shawn的个人博客
09-28 1297
开发完成后，生产就绪需要做哪些工作呢？我认为，以下三方面的工作最重要。提供健康检测接口。传统采用 ping 的方式对应用进行探活检测并不准确。有的时候，应用的关键内部或外部依赖已经离线，导致其根本无法正常工作，但其对外的 Web 端口或管理端口是可以 ping 通的。我们应该提供一个专有的监控检测接口，并尽可能触达一些内部组件。暴露应用内部信息。
了解Java线程池的原理和监控
Younger
10-24 3480
了解Java线程池的原理和监控
spring boot 高并发
12-01
同时，Spring Boot 还提供了监控和调优的功能，开发人员可以通过整合监控工具来实时监控系统的性能和资源使用情况，及时发现并发瓶颈并进行调优，保证系统的稳定性和高并发处理能力。 此外，Spring Boot 还支持集群...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值