本文实例为大家分享了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、无返回结果
2、有返回结果
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。
原文链接:http://www.cnblogs.com/yangtze-yufei/p/7754147.html