我是如何把SpringBoot項目的並發提升十倍量級的

背景

生產環境偶爾會有一些慢請求導致系統性能下降，吞吐量下降，下面介紹幾種優化建議。

方案

1、undertow替換tomcat

電子商務類型網站大多都是短請求，一般響應時間都在100ms，這時可以將web容器從tomcat替換為undertow，下面介紹下步驟：1、增加pom配置

1.  
   <dependency>
2.  
       <groupid>org.springframework.boot</groupid>
3.  
       <artifactid>spring-boot-starter-web</artifactid>
4.  
       <exclusions>
5.  
          <exclusion>
6.  
             <groupid>org.springframework.boot</groupid>
7.  
             <artifactid>spring-boot-starter-tomcat</artifactid>
8.  
          </exclusion>
9.  
       </exclusions>
10.  
    </dependency>
11.  
    <dependency>
12.  
        <groupid>org.springframework.boot</groupid>
13.  
        <artifactid>spring-boot-starter-undertow</artifactid>
14.  
    </dependency>

2、增加相關配置

1.  
   server:
2.  
     undertow:
3.  
       direct-buffers:  true
4.  
       io-threads:  4
5.  
       worker-threads:  160

重新啟動可以在控制台看到容器已經切換為undertow了

2、緩存

將部分熱點數據或者靜態數據放到本地緩存或者redis中，如果有需要可以定時更新緩存數據

3、異步

在代碼過程中我們很多代碼都不需要等返回結果，也就是部分代碼是可以並行執行，這個時候可以使用異步，最簡單的方案是使用springboot提供的@Async注解，當然也可以通過線程池來實現，下面簡單介紹下異步步驟。1、pom依賴 一般springboot引入web相關依賴就行

1.  
   <dependency>
2.  
       <groupid>org.springframework.boot</groupid>
3.  
       <artifactid>spring-boot-starter-web</artifactid>
4.  
   </dependency>

2、在啟動類中增加@EnableAsync注解

1.  
   @EnableAsync
2.  
   @SpringBootApplication
3.  
   public class AppApplication
4.  
   {
5.  
       public static void main(String[] args)
6.  
       {
7.  
           SpringApplication.run(AppApplication.class, args);
8.  
       }
9.  
   }

3、需要時在指定方法中增加@Async注解，如果是需要等待返回值，則demo如下

1.  
   @Async
2.  
   public Future< string> doReturn(int i){
3.  
       try {
4.  
            // 這個方法需要調用500毫秒
5.  
            Thread.sleep( 500);
6.  
        } catch (InterruptedException e) {
7.  
          e.printStackTrace();
8.  
       }
9.  
       / 消息匯總
10.  
         return new AsyncResult&lt;&gt;("異步調用");
11.  
    }

4、如果有線程變量或者logback中的mdc，可以增加傳遞

1.  
   import org.slf4j.MDC;
2.  
   import org.springframework.context.annotation.Configuration;
3.  
   import org.springframework.core.task.TaskDecorator;
4.  
   import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
5.  
   import org.springframework.scheduling.annotation.EnableAsync;
6.  
   import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
7.  
    
8.  
   import java.util.Map;
9.  
   import java.util.concurrent.Executor;
10.  
     
11.  
    /**
12.  
     * @Description:
13.  
     */
14.  
    @EnableAsync
15.  
    @Configuration
16.  
    public class AsyncConfig extends AsyncConfigurerSupport {
17.  
        @Override
18.  
        public Executor getAsyncExecutor() {
19.  
            ThreadPoolTaskExecutor executor =  new ThreadPoolTaskExecutor();
20.  
            executor.setTaskDecorator( new MdcTaskDecorator());
21.  
            executor.initialize();
22.  
             return executor;
23.  
        }
24.  
    }
25.  
     
26.  
    class MdcTaskDecorator implements TaskDecorator {
27.  
     
28.  
        @Override
29.  
        public Runnable decorate(Runnable runnable) {
30.  
            Map< string, string> contextMap = MDC.getCopyOfContextMap();
31.  
             return () -&gt; {
32.  
                try {
33.  
                    MDC.setContextMap(contextMap);
34.  
                    runnable.run();
35.  
                } finally {
36.  
                    MDC.clear();
37.  
                }
38.  
            };
39.  
        }
40.  
    }

5、有時候異步需要增加阻塞

1.  
   import lombok.extern.slf4j.Slf4j;
2.  
   import org.springframework.context.annotation.Bean;
3.  
   import org.springframework.context.annotation.Configuration;
4.  
   import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
5.  
    
6.  
   import java.util.concurrent.Executor;
7.  
   import java.util.concurrent.ThreadPoolExecutor;
8.  
    
9.  
   @Configuration
10.  
    @Slf4j
11.  
    public class TaskExecutorConfig {
12.  
     
13.  
        @Bean( "localDbThreadPoolTaskExecutor")
14.  
        public Executor threadPoolTaskExecutor() {
15.  
            ThreadPoolTaskExecutor taskExecutor =  new ThreadPoolTaskExecutor();
16.  
            taskExecutor.setCorePoolSize( 5);
17.  
            taskExecutor.setMaxPoolSize( 200);
18.  
            taskExecutor.setQueueCapacity( 200);
19.  
            taskExecutor.setKeepAliveSeconds( 100);
20.  
            taskExecutor.setThreadNamePrefix( "LocalDbTaskThreadPool");
21.  
            taskExecutor.setRejectedExecutionHandler((Runnable r, ThreadPoolExecutor executor) -&gt; {
22.  
                         if (!executor.isShutdown()) {
23.  
                            try {
24.  
                                Thread.sleep( 300);
25.  
                                executor.getQueue().put(r);
26.  
                            } catch (InterruptedException e) {
27.  
                                log.error(e.toString(), e);
28.  
                                Thread.currentThread().interrupt();
29.  
                            }
30.  
                        }
31.  
                    }
32.  
            );
33.  
            taskExecutor.initialize();
34.  
             return taskExecutor;
35.  
        }
36.  
     
37.  
     
38.  
    }

4、業務拆分

可以將比較耗時或者不同的業務拆分出來提供單節點的吞吐量

5、集成消息隊列

有很多場景對數據實時性要求不那么強的，或者對業務進行業務容錯處理時可以將消息發送到kafka，然后延時消費。舉個例子，根據條件查詢指定用戶發送推送消息，這里可以時按時、按天、按月等等，這時就