SpringBoot2.0之异步任务（async）和 java8 CompletableFuture的调用_springboot completablefuture.supplyasync

1.我们先介绍java8 的异步调用：CompletableFuture

用CompletableFuture.supplyAsync（）定义要执行的异步任务

public class java8Async {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newFixedThreadPool(10);
 
		// CompletableFuture.supplyAsync（），定义要执行的异步任务
		 CompletableFuture.supplyAsync(new Supplier<String>() {
 
			@Override
			public String get() {
				// TODO Auto-generated method stub
				try {
					System.out.println("任务1");
					// 睡眠1s
					TimeUnit.SECONDS.sleep(1);
					System.out.println("任务2");
				} catch (Exception e) {
					e.printStackTrace();
				}
				return "返回数据async";
			}
		}, executor);
		// return
		System.out.println("任务执行完成");
	}
 
}

执行结果：

 

当异步任务需要返回数据那怎么办呢？

用cupdResult.thenAccept(new Consumer<String>() ， 重写accept（）方法去定义回调函数

public class java8Async {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newFixedThreadPool(10);
 
		// CompletableFuture.supplyAsync（），定义要执行的异步任务
		CompletableFuture<String> asyncResult = CompletableFuture.supplyAsync(new Supplier<String>() {
 
			@Override
			public String get() {
				// TODO Auto-generated method stub
				try {
					System.out.println("任务1");
					// 睡眠1s
					TimeUnit.SECONDS.sleep(1);
					System.out.println("任务2");
				} catch (Exception e) {
					e.printStackTrace();
				}
				return "返回数据async";
			}
		}, executor);
 
		// asyncResult.thenAccept(new Consumer<String>() ， 重写accept（）方法去定义回调函数
		asyncResult.thenAccept(new Consumer<String>() {
			public void accept(String arg0) {
				System.out.println("return =" + arg0);
			}
		});
		// return
		System.out.println("任务执行完成");
	}
 
}

执行结果：

2.我们介绍springboot的异步任务：springboot给我们提供了注解方法，在启动类上添加@EnableAsync注解，在需要用到异步任务的实现方法上添加@Async注解，然后就可以用了，详情如下：

启动类：添加@EnableAsync注解

package com.async;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.transaction.annotation.EnableTransactionManagement;
 
/**  
* @ClassName: OtherApplication  
* @Description: TODO()  
* @author lixin(1309244704@qq.com)  
* @date 2018年10月13日 下午4:43:35  
* @version V1.0  
*/ 
@SpringBootApplication
@EnableTransactionManagement
@EnableAsync
public class OtherApplication {
 
	public static void main(String[] args) {
		SpringApplication.run(OtherApplication.class, args);
	}
}

然后在你需要异步调用的方法上添加注解

package com.async.boot;
 
import java.util.concurrent.Future;
 
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
/**  
* @ClassName: AsyncAfterServiceImpl  
* @Description: TODO()  
* @author lixin(1309244704@qq.com)  
* @date 2018年10月13日 下午4:50:38  
* @version V1.0  
*/ 
 
@Service
public class AsyncAfterServiceImpl implements AsyncAfterService{
	
	@Transactional
	@Override
	@Async
	public Future<String>  asyncAfterOne() throws InterruptedException {
		System.err.println("asyncAfterOne任务以执行");
		return new AsyncResult<String>("asyncAfterOne执行完毕");
	}
	
	@Transactional
	@Override
	@Async
	public Future<String> asyncAfterTwo() throws InterruptedException {
		long currentTimeMillis = System.currentTimeMillis();
		Thread.sleep(3000);
		long currentTimeMillis1 = System.currentTimeMillis();
		System.err.println("asyncAfterTwo任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
		return new AsyncResult<String>("asyncAfterTwo执行完毕");
	}
 
	@Transactional
	@Override
	@Async
	public Future<String> asyncAfterThree() throws InterruptedException {
		long currentTimeMillis = System.currentTimeMillis();
		Thread.sleep(6000);
		long currentTimeMillis1 = System.currentTimeMillis();
		System.err.println("asyncAfterThree任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
		return new AsyncResult<String>("asyncAfterThree执行完毕");
	}
	
}

然后是调用类：

package com.async.boot;
 
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
/**  
* @ClassName: AsyncServiceImpl  
* @Description: TODO()  
* @author lixin(1309244704@qq.com)  
* @date 2018年10月13日 下午4:54:15  
* @version V1.0  
*/ 
@Service
public class AsyncServiceImpl implements AsyncService{
	
	@Autowired
	private AsyncAfterService asyncAfterService;
	
	
	@Transactional
	@Override
	public String asyncOne() throws InterruptedException {
		long currentTimeMillis = System.currentTimeMillis();
		asyncAfterService.asyncAfterOne();
		asyncAfterService.asyncAfterTwo();
		asyncAfterService.asyncAfterThree();
		long currentTimeMillis1 = System.currentTimeMillis();
		return "asyncAfter任务总耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms";
	}
	
	@Transactional
	@Override
	public String asyncTwo() throws InterruptedException, ExecutionException {
		long currentTimeMillis = System.currentTimeMillis();
		Future<String> two = asyncAfterService.asyncAfterTwo();
		Future<String> three = asyncAfterService.asyncAfterThree();
		String result = null;
		while (true) {
			if(two.isDone() && three.isDone()) {
				System.err.println(two.get());
				System.err.println(three.get());
				// 两个任务都调用完成，跳出循环
				break;
			}
			Thread.sleep(1000);
		}
		long currentTimeMillis1 = System.currentTimeMillis();
		result = "asyncAfter任务总耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms";
		return result;
	}
	
}

然后是测试类：

package com.async;
 
 
import java.util.concurrent.ExecutionException;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
 
import com.async.boot.AsyncService;
 
 
@RunWith(SpringRunner.class)  
@SpringBootTest(classes = OtherApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@EnableAutoConfiguration
public class AsyncTest {
	
	@Autowired
	private AsyncService asyncService;
 
	
	@Test
	public void asyncOne() throws InterruptedException {
		System.err.println(asyncService.asyncOne());
		Thread.sleep(8000);
	}
	
	@Test
	public void asyncTwo() throws InterruptedException, ExecutionException {
		System.err.println(asyncService.asyncTwo());
	}
	
}

方法执行结果分别如下：

 

 github项目demo地址：https://github.com/LX1309244704/SpringBoot-master/tree/master/springboot-async