Spring boot多线程配置方法

时间:2022-10-19 09:16:15

本文实例为大家分享了Spring boot多线程配置的具体代码,供大家参考,具体内容如下

1、配置线程配置类

?
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
package test;
 
import java.util.concurrent.Executor;
 
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
@Configuration
@ComponentScan("test")
@EnableAsync
// 线程配置类
public class AsyncTaskConfig implements AsyncConfigurer {
 
  // ThredPoolTaskExcutor的处理流程
  // 当池子大小小于corePoolSize,就新建线程,并处理请求
  // 当池子大小等于corePoolSize,把请求放入workQueue中,池子里的空闲线程就去workQueue中取任务并处理
  // 当workQueue放不下任务时,就新建线程入池,并处理请求,如果池子大小撑到了maximumPoolSize,就用RejectedExecutionHandler来做拒绝处理
  // 当池子的线程数大于corePoolSize时,多余的线程会等待keepAliveTime长时间,如果无请求可处理就自行销毁
 
  @Override
  public Executor getAsyncExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    taskExecutor.setCorePoolSize(5);// 最小线程数
    taskExecutor.setMaxPoolSize(10);// 最大线程数
    taskExecutor.setQueueCapacity(25);// 等待队列
 
    taskExecutor.initialize();
 
    return taskExecutor;
  }
 
  @Override
  public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
    return null;
  }
}

2、定义线程执行任务类

?
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
package test;
 
import java.util.Random;
import java.util.concurrent.Future;
 
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
 
@Service
// 线程执行任务类
public class AsyncTaskService {
 
  Random random = new Random();// 默认构造方法
 
  @Async
  // 表明是异步方法
  // 无返回值
  public void executeAsyncTask(Integer i) {
    System.out.println("执行异步任务:" + i);
  }
 
  /**
   * 异常调用返回Future
   *
   * @param i
   * @return
   * @throws InterruptedException
   */
  @Async
  public Future<String> asyncInvokeReturnFuture(int i) throws InterruptedException {
    System.out.println("input is " + i);
    Thread.sleep(1000 * random.nextInt(i));
 
    Future<String> future = new AsyncResult<String>("success:" + i);// Future接收返回值,这里是String类型,可以指明其他类型
 
    return future;
  }
}

3、调用

?
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
package test;
 
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
 
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.task.TaskRejectedException;
 
public class Application {
 
  public static void main(String[] args) throws InterruptedException, ExecutionException {
    // testVoid();
 
    testReturn();
  }
 
  // 测试无返回结果
  private static void testVoid() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AsyncTaskConfig.class);
    AsyncTaskService asyncTaskService = context.getBean(AsyncTaskService.class);
 
    // 创建了20个线程
    for (int i = 1; i <= 20; i++) {
      asyncTaskService.executeAsyncTask(i);
    }
 
    context.close();
  }
 
  // 测试有返回结果
  private static void testReturn() throws InterruptedException, ExecutionException {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AsyncTaskConfig.class);
    AsyncTaskService asyncTaskService = context.getBean(AsyncTaskService.class);
 
    List<Future<String>> lstFuture = new ArrayList<Future<String>>();// 存放所有的线程,用于获取结果
 
    // 创建100个线程
    for (int i = 1; i <= 100; i++) {
      while (true) {
        try {
          // 线程池超过最大线程数时,会抛出TaskRejectedException,则等待1s,直到不抛出异常为止
          Future<String> future = asyncTaskService.asyncInvokeReturnFuture(i);
          lstFuture.add(future);
 
          break;
        } catch (TaskRejectedException e) {
          System.out.println("线程池满,等待1S。");
          Thread.sleep(1000);
        }
      }
    }
 
    // 获取值。get是阻塞式,等待当前线程完成才返回值
    for (Future<String> future : lstFuture) {
      System.out.println(future.get());
    }
 
    context.close();
  }
}

maven配置

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<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>TestAysc</groupId>
 <artifactId>TestAysc</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <dependencies>
   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot</artifactId>
     <version>1.5.6.RELEASE</version>
   </dependency>
   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aop</artifactId>
     <version>4.3.10.RELEASE</version>
   </dependency>
 </dependencies>
</project>

结果展示:

1、无返回结果

Spring boot多线程配置方法

2、有返回结果

Spring boot多线程配置方法

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。

原文链接:http://www.cnblogs.com/yangtze-yufei/p/7754147.html