Spring异步

1.1 xml配置

<task:annotation-driven executor="asyncExecutor" />

<task:executor id="asyncExecutor" pool-size="100-10000" queue-capacity="10"/>

1.2 java配置

@Configuration  
@EnableAsync  //开启异步
public class SpringConfig {  
    private int corePoolSize = 10;  
    private int maxPoolSize = 200;  
    private int queueCapacity = 10;  

     private String ThreadNamePrefix = "MyLogExecutor-";  

    @Bean("asyncService1") 
    public Executor logExecutor() {  
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();  
        executor.setCorePoolSize(corePoolSize);  
        executor.setMaxPoolSize(maxPoolSize);  
        executor.setQueueCapacity(queueCapacity);  
        executor.setThreadNamePrefix(ThreadNamePrefix);  
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
        executor.initialize();  
        return executor;  
    }  
} 

@Component
@Async("asyncService1") //当调用改方法时，会异步调用和@Bean中参数对应
public class AsyncService {
	public void testAsync() {
	    System.out.println("begin..开始调用");
	    try {
	    	Thread.sleep(10000);
	    } catch (InterruptedException e) {
	    	System.out.println("睡眠");
    	}
    	System.out.println("end...结束调用");
    }
}

1.3 异步任务类

Service

@Component
public class AsyncTask {
	
	@Async
	public Future<String> task1() throws InterruptedException{
		long currentTimeMillis = System.currentTimeMillis();
		Thread.sleep(1000);
		long currentTimeMillis1 = System.currentTimeMillis();
		System.out.println("task1任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
		return new AsyncResult<String>("task1执行完毕");
	}
	
	@Async
	public Future<String> task2() throws InterruptedException{
		long currentTimeMillis = System.currentTimeMillis();
		Thread.sleep(2000);
		long currentTimeMillis1 = System.currentTimeMillis();
		System.out.println("task2任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
		return new AsyncResult<String>("task2执行完毕");
	}
	@Async
	public Future<String> task3() throws InterruptedException{
		long currentTimeMillis = System.currentTimeMillis();
		Thread.sleep(3000);
		long currentTimeMillis1 = System.currentTimeMillis();
		System.out.println("task3任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
		return new AsyncResult<String>("task3执行完毕");
	}
}

Controller

@RequestMapping("")
@RestController
public class AsyncTaskController {
	
	@Autowired
	private AsyncTask asyncTask;
	
	@RequestMapping("")
	public String doTask() throws InterruptedException{
		long currentTimeMillis = System.currentTimeMillis();
		Future<String> task1 = asyncTask.task1();
		Future<String> task2 = asyncTask.task2();
		Future<String> task3 = asyncTask.task3();
		String result = null;
		for (;;) {
			if(task1.isDone() && task2.isDone() && task3.isDone()) {
				// 三个任务都调用完成，退出循环等待
				break;
			}
			Thread.sleep(1000);
		}
		long currentTimeMillis1 = System.currentTimeMillis();
		result = "task任务总耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms";
		return result;
	}
}

1.4 配置参数详解：

1. id：当配置多个executor时，被@Async(“id”)指定使用；也被作为线程名的前缀。
2. core-size：最小的线程数，缺省：1（该线程会一直存在）core-size：最小的线程数，缺省：1（该线程会一直存在）
3. max-size：最大的线程数，缺省：Integer.MAX_VALUE（当线程数大于core-size+queue-capacity会创建最大线程，keep-alive设置该线程会被结束掉）max-size：最大的线程数，缺省：Integer.MAX_VALUE（当线程数大于core-size+queue-capacity会创建最大线程，keep-alive设置该线程会被结束掉）
4. queue-capacity：当最小的线程数已经被占用满后，新的任务会被放进queue里面，当这个queue的capacity也被占满之后，pool里面会创建新线程处理这个任务，直到总线程数达到了maxsize，这时系统会拒绝这个任务并抛出TaskRejectedException异常（缺省配置的情况下，可以通过rejection-policy来决定如何处理这种情况）。缺省值为：Integer.MAX_VALUEqueue-capacity：当最小的线程数已经被占用满后，新的任务会被放进queue里面，当这个queue的capacity也被占满之后，pool里面会创建新线程处理这个任务，直到总线程数达到了maxsize，这时系统会拒绝这个任务并抛出TaskRejectedException异常（缺省配置的情况下，可以通过rejection-policy来决定如何处理这种情况）。缺省值为：Integer.MAX_VALUE
5. keep-alive：超过coresize的那些线程，任务完成后，再经过这个时长（秒）会被结束掉keep-alive：超过coresize的那些线程，任务完成后，再经过这个时长（秒）会被结束掉
6. rejection-policy：当pool已经达到max size的时候，如何处理新任务rejection-policy：当pool已经达到max size的时候，如何处理新任务
   6.1. ABORT（缺省）：抛出TaskRejectedException异常，然后不执行6.1. ABORT（缺省）：抛出TaskRejectedException异常，然后不执行
   6.2. DISCARD：不执行，也不抛出异常
   6.3. DISCARD_OLDEST：丢弃queue中最旧的那个任务（会抛弃队列中对开式进入的）
   6.4. CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行（会阻塞，等待所有core-size，queue-capacity，max-size执）