2. 程式人生 > >springboot線程池的使用和擴展

springboot線程池的使用和擴展

阿新 • • 發佈：2018-05-07
總數 auto ger tomcat tag LV reporting mls ted

我們常用ThreadPoolExecutor提供的線程池服務，springboot框架提供了@Async註解，幫助我們更方便的將業務邏輯提交到線程池中異步執行，今天我們就來實戰體驗這個線程池服務；

本文地址：http://blog.csdn.net/boling_cavalry/article/details/79120268

實戰環境

  1. windowns10；
  2. jdk1.8；
  3. springboot 1.5.9.RELEASE；
  4. 開發工具：IntelliJ IDEA；

實戰源碼

本次實戰的源碼可以在我的GitHub下載，地址：[email protected]:zq2599/blog_demos.git，項目主頁：https://github.com/zq2599/blog_demos

這裏面有多個工程，本次用到的工程為threadpooldemoserver，如下圖紅框所示：
技術分享圖片

實戰步驟梳理

本次實戰的步驟如下：
1. 創建springboot工程；
2. 創建Service層的接口和實現；
3. 創建controller，開發一個http服務接口，裏面會調用service層的服務；
4. 創建線程池的配置；
5. 將Service層的服務異步化，這樣每次調用都會都被提交到線程池異步執行；
6. 擴展ThreadPoolTaskExecutor，在提交任務到線程池的時候可以觀察到當前線程池的情況；

創建springboot工程

用IntelliJ IDEA創建一個springboot的web工程threadpooldemoserver，pom.xml內容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.bolingcavalry</groupId>
    <artifactId>threadpooldemoserver</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>threadpooldemoserver</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
  • 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

創建Service層的接口和實現

創建一個service層的接口AsyncService，如下：

public interface AsyncService {

    /**
     * 執行異步任務
     */
    void executeAsync();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

對應的AsyncServiceImpl，實現如下：

@Service
public class AsyncServiceImpl implements AsyncService {

    private static final Logger logger = LoggerFactory.getLogger(AsyncServiceImpl.class);

    @Override
    public void executeAsync() {
        logger.info("start executeAsync");
        try{
            Thread.sleep(1000);
        }catch(Exception e){
            e.printStackTrace();
        }
        logger.info("end executeAsync");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

這個方法做的事情很簡單：sleep了一秒鐘；

創建controller

創建一個controller為Hello，裏面定義一個http接口，做的事情是調用Service層的服務，如下：

@RestController
public class Hello {

    private static final Logger logger = LoggerFactory.getLogger(Hello.class);

    @Autowired
    private AsyncService asyncService;

    @RequestMapping("/")
    public String submit(){
        logger.info("start submit");

        //調用service層的任務
        asyncService.executeAsync();

        logger.info("end submit");

        return "success";
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

至此，我們已經做好了一個http請求的服務，裏面做的事情其實是同步的，接下來我們就開始配置springboot的線程池服務，將service層做的事情都提交到線程池中去處理；

springboot的線程池配置

創建一個配置類ExecutorConfig，用來定義如何創建一個ThreadPoolTaskExecutor，要使用@Configuration和@EnableAsync這兩個註解，表示這是個配置類，並且是線程池的配置類，如下所示：

@Configuration
@EnableAsync
public class ExecutorConfig {

    private static final Logger logger = LoggerFactory.getLogger(ExecutorConfig.class);

    @Bean
    public Executor asyncServiceExecutor() {
        logger.info("start asyncServiceExecutor");
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //配置核心線程數
        executor.setCorePoolSize(5);
        //配置最大線程數
        executor.setMaxPoolSize(5);
        //配置隊列大小
        executor.setQueueCapacity(99999);
        //配置線程池中的線程的名稱前綴
        executor.setThreadNamePrefix("async-service-");

        // rejection-policy：當pool已經達到max size的時候，如何處理新任務
        // CALLER_RUNS：不在新線程中執行任務，而是有調用者所在的線程來執行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //執行初始化
        executor.initialize();
        return executor;
    }
}
  • 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

註意，上面的方法名稱為asyncServiceExecutor，稍後馬上用到；

將Service層的服務異步化

打開AsyncServiceImpl.java，在executeAsync方法上增加註解@Async(“asyncServiceExecutor”)，asyncServiceExecutor是前面ExecutorConfig.java中的方法名，表明executeAsync方法進入的線程池是asyncServiceExecutor方法創建的，如下：

@Override
    @Async("asyncServiceExecutor")
    public void executeAsync() {
        logger.info("start executeAsync");
        try{
            Thread.sleep(1000);
        }catch(Exception e){
            e.printStackTrace();
        }
        logger.info("end executeAsync");
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

驗證效果

  1. 將這個springboot運行起來（pom.xml所在文件夾下執行mvn spring-boot:run）；
  2. 在瀏覽器輸入：http://localhost:8080；
  3. 在瀏覽器用F5按鈕快速多刷新幾次；
  4. 在springboot的控制臺看見日誌如下：
2018-01-21 22:43:18.630  INFO 14824 --- [nio-8080-exec-8] c.b.t.controller.Hello                   : start submit
2018-01-21 22:43:18.630  INFO 14824 --- [nio-8080-exec-8] c.b.t.controller.Hello                   : end submit
2018-01-21 22:43:18.929  INFO 14824 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 22:43:18.930  INFO 14824 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync
2018-01-21 22:43:19.005  INFO 14824 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 22:43:19.006  INFO 14824 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync
2018-01-21 22:43:19.175  INFO 14824 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 22:43:19.175  INFO 14824 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync
2018-01-21 22:43:19.326  INFO 14824 --- [async-service-4] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 22:43:19.495  INFO 14824 --- [async-service-5] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 22:43:19.930  INFO 14824 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 22:43:20.006  INFO 14824 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 22:43:20.191  INFO 14824 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

如上日誌所示，我們可以看到controller的執行線程是”nio-8080-exec-8”，這是tomcat的執行線程，而service層的日誌顯示線程名為“async-service-1”，顯然已經在我們配置的線程池中執行了，並且每次請求中，controller的起始和結束日誌都是連續打印的，表明每次請求都快速響應了，而耗時的操作都留給線程池中的線程去異步執行；

擴展ThreadPoolTaskExecutor

雖然我們已經用上了線程池，但是還不清楚線程池當時的情況，有多少線程在執行，多少在隊列中等待呢？這裏我創建了一個ThreadPoolTaskExecutor的子類，在每次提交線程的時候都會將當前線程池的運行狀況打印出來，代碼如下：

public class VisiableThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {
    private static final Logger logger = LoggerFactory.getLogger(VisiableThreadPoolTaskExecutor.class);

    private void showThreadPoolInfo(String prefix){
        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();

        if(null==threadPoolExecutor){
            return;
        }

        logger.info("{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]",
                this.getThreadNamePrefix(),
                prefix,
                threadPoolExecutor.getTaskCount(),
                threadPoolExecutor.getCompletedTaskCount(),
                threadPoolExecutor.getActiveCount(),
                threadPoolExecutor.getQueue().size());
    }

    @Override
    public void execute(Runnable task) {
        showThreadPoolInfo("1. do execute");
        super.execute(task);
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        showThreadPoolInfo("2. do execute");
        super.execute(task, startTimeout);
    }

    @Override
    public Future<?> submit(Runnable task) {
        showThreadPoolInfo("1. do submit");
        return super.submit(task);
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        showThreadPoolInfo("2. do submit");
        return super.submit(task);
    }

    @Override
    public ListenableFuture<?> submitListenable(Runnable task) {
        showThreadPoolInfo("1. do submitListenable");
        return super.submitListenable(task);
    }

    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        showThreadPoolInfo("2. do submitListenable");
        return super.submitListenable(task);
    }
}
  • 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

如上所示，showThreadPoolInfo方法中將任務總數、已完成數、活躍線程數，隊列大小都打印出來了，然後Override了父類的execute、submit等方法，在裏面調用showThreadPoolInfo方法，這樣每次有任務被提交到線程池的時候，都會將當前線程池的基本情況打印到日誌中；

修改ExecutorConfig.java的asyncServiceExecutor方法，將ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor()改為ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor()，如下所示：

@Bean
    public Executor asyncServiceExecutor() {
        logger.info("start asyncServiceExecutor");
        //使用VisiableThreadPoolTaskExecutor
        ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor();
        //配置核心線程數
        executor.setCorePoolSize(5);
        //配置最大線程數
        executor.setMaxPoolSize(5);
        //配置隊列大小
        executor.setQueueCapacity(99999);
        //配置線程池中的線程的名稱前綴
        executor.setThreadNamePrefix("async-service-");

        // rejection-policy：當pool已經達到max size的時候，如何處理新任務
        // CALLER_RUNS：不在新線程中執行任務，而是有調用者所在的線程來執行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //執行初始化
        executor.initialize();
        return executor;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

再次啟動該工程，再瀏覽器反復刷新http://localhost:8080，看到的日誌如下：

2018-01-21 23:04:56.113  INFO 15580 --- [nio-8080-exec-1] c.b.t.e.VisiableThreadPoolTaskExecutor   : async-service-, 2. do submit,taskCount [99], completedTaskCount [85], activeCount [5], queueSize [9]
2018-01-21 23:04:56.113  INFO 15580 --- [nio-8080-exec-1] c.b.t.controller.Hello                   : end submit
2018-01-21 23:04:56.225  INFO 15580 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 23:04:56.225  INFO 15580 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync
2018-01-21 23:04:56.240  INFO 15580 --- [nio-8080-exec-2] c.b.t.controller.Hello                   : start submit
2018-01-21 23:04:56.240  INFO 15580 --- [nio-8080-exec-2] c.b.t.e.VisiableThreadPoolTaskExecutor   : async-service-, 2. do submit,taskCount [100], completedTaskCount [86], activeCount [5], queueSize [9]
2018-01-21 23:04:56.240  INFO 15580 --- [nio-8080-exec-2] c.b.t.controller.Hello                   : end submit
2018-01-21 23:04:56.298  INFO 15580 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 23:04:56.298  INFO 15580 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync
2018-01-21 23:04:56.372  INFO 15580 --- [nio-8080-exec-3] c.b.t.controller.Hello                   : start submit
2018-01-21 23:04:56.373  INFO 15580 --- [nio-8080-exec-3] c.b.t.e.VisiableThreadPoolTaskExecutor   : async-service-, 2. do submit,taskCount [101], completedTaskCount [87], activeCount [5], queueSize [9]
2018-01-21 23:04:56.373  INFO 15580 --- [nio-8080-exec-3] c.b.t.controller.Hello                   : end submit
2018-01-21 23:04:56.444  INFO 15580 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync
2018-01-21 23:04:56.445  INFO 15580 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

註意這一行日誌：2. do submit,taskCount [101], completedTaskCount [87], activeCount [5], queueSize [9]

這說明提交任務到線程池的時候，調用的是submit(Callable task)這個方法，當前已經提交了101個任務，完成了87個，當前有5個線程在處理任務，還剩9個任務在隊列中等待，線程池的基本情況一路了然；

至此，springboot線程池服務的實戰就完成了，希望能幫您在工程中快速實現異步服務；

springboot線程池的使用和擴展

相關推薦

springboot線程池的使用和擴展

總數 auto ger tomcat tag LV reporting mls ted 我們常用ThreadPoolExecutor提供的線程池服務，springboot框架提供了@Async註解，幫助我們更方便的將業務邏輯提交到線程池中異步執行，今天我們就來實戰體驗這個線

線程池和任務

pool call public 異常 token 操作系統 null deb gets 線程池 線程池基礎 創建線程和銷毀線程是一個昂貴的操作，要耗費大量的時間。由於操作系統必須調度可運行的線程並執行上線文切換，所以太多的線程還對性能不利。

python爬蟲之線程池和進程池

偏見 通信 內存空間 正常 io操作 爬取 網站 總結 性能 一、需求 　　最近準備爬取某電商網站的數據，先不考慮代理、分布式，先說效率問題（當然你要是請求的太快就會被封掉，親測，400個請求過去，服務器直接拒絕連接，心碎），步入正題。一般情況下小白的我們第一個想到的是fo

C#多線程編程（1）--線程，線程池和Task

gpo 第一次 span via 任務隊列 返回值 異步 如果 是你 　　新開了一個多線程編程系列，該系列主要講解C#中的多線程編程。　 利用多線程的目的有2個: 一是防止UI線程被耗時的程序占用，導致界面卡頓；二是能夠利用多核CPU的資源，提高運行效率。 　　我沒有

Java之線程池和Lambda表達式

例子 少見 sin 防止 單例模式 多線程 immediate creat 問題 線程池和lambda表達式 學習線程池和lambda表達式的理解 補充一個知識點(單例設計模式) 在多線程中,我們只需要一個任務類,為了防止創建多個任務類,這個時候就需要用到單例模式,單例模式

多進程 multiprocessing 多線程Threading 線程池和進程池concurrent.futures

不用 文件 進程池 lba ren 行操作 接收參數 出現 ali multiprocessing.procsess 定義一個函數 def func():pass 在if __name__=="__main__":中實例化 p = process(target=子進程要執

JAVA多線程(三) 線程池和鎖的深度化

class 只有一個 computer 線程創建 關系 nts 自己的 穩定 這樣的 github演示代碼地址：https://github.com/showkawa/springBoot_2017/tree/master/spb-demo/src/main/java/c

線程進階之線程隊列、線程池和協程

最小 for循環 display llb key adf func from 通信 本節目錄： 1.線程隊列 2.線程池 3.協程 一、線程隊列 　　線程之間的通信我們列表行不行呢，當然行，那麽隊列和列表有什麽區別呢？ 　　queue隊列 ：使用import queue

線程隊列,線程池和協程

class lap 獲取 阻塞 n) spawn sta submit bmi 線程的其他方法: 　　threading.current_thread() #當前線程對象 　　getName() # 獲取線程名 　　ident # 獲取線程id 　 threadin

關於C#線程，線程池和並行運算的簡單使用和對比

作者 rgs 方便 線程池 https 賦值 一定的 pool idl 轉自：https://www.cnblogs.com/jeffwongishandsome/archive/2010/11/12/1876137.html 先大概看一下控制臺應用程序的Main方法的主要

java和spring 線程池總結

一段 getname span 只有一個 [] 觸發 sts time execute 1. spring 的線程池 ThreadPoolTaskExecutor @Configuration public class ThreadPoolConfig {

Java線程池關閉1-shutdown和isTerminated<轉>

ride shu csdn nat err interrupt .net fin cat shutdownvoid shutdown()啟動一次順序關閉，執行以前提交的任務，但不接受新任務。若已經關閉，則調用沒有其他作用。拋出：SecurityException - 如果安

ThreadPoolExecutor線程池的分析和使用

pro rep interrupt rup bsp roc 停止 可用 method 1. 引言 合理利用線程池能夠帶來三個好處。 第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。 第二：提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立

Java線程池的分析和使用

服務器 dex man nan generate att width 微秒 cpu 1. 引言 合理利用線程池能夠帶來三個好處。第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。第二：提高響應速度。當任務到達 時，任務可以不需要的等到線程創建就

Android的線程和線程池

ccf pos 在線 bst 網絡請求 四大 ask ron 底層 1、背景 Android中，線程分為主線程和子線程

12.深入線程池_流程和原理

thread 帶來 discard 分享 取消 fixed 由於 ref epo 參考博文：http://blog.csdn.net/mark_lq/article/details/50346999 一、線程池的基本類結構 　　合理利用線程池能夠帶來三個好處。 　　1.降低

AsyncTask、HandlerThread、IntentService和線程池

ssa 輸入參數 異步操作 出現 ams tro run rri 百分比 AsyncTask 　　AsyncTask 是一種輕量級的異步任務類，可以在線程池中執行後臺任務，然後把執行的進度和最終結果傳遞給主線程用於更新UI。 可以直接繼承AsyncTask,在類中實現異步操

線程和線程池的使用

ren 參考 oid 工作 adp pre 定義 ++ edt 參考：http://www.cnblogs.com/dolphin0520/p/3932921.html 1、線程：循環新建10個線程 註意：final定義的變量才能在run()方法裏使用 pack

線程池的使用及ThreadPoolExecutor的execute和addWorker源碼分析

單位 bool 集合 handler 意思 size 執行順序 targe execute 說明：本作者是文章的原創作者，轉載請註明出處：本文地址：http://www.cnblogs.com/qm-article/p/7821602.html 一、線程池的介紹

SpringBoot開發案例之多任務並行+線程池處理

Java SpringBoot 前言前幾篇文章著重介紹了後端服務數據庫和多線程並行處理優化，並示例了改造前後的偽代碼邏輯。當然了，優化是無止境的，前人栽樹後人乘涼。作為我們開發者來說，既然站在了巨人的肩膀上，就要寫出更加優化的程序。SpringBoot開發案例之JdbcTemplate批量操作Spri