da
对于多任务耗时的业务场景，一般我们会用到线程异步处理,在以前我们用 Thread 或者 Runnable 来实现异步，这是oracle官方做法，不过缺点很明显
对于复杂业务场景需要配置线程池
代码繁杂，对于新手容易造成不必要的bug
如果涉及到线程锁或线程通讯就棘手了
现在，java8为我们提供了CompletableFuture类，可以完全解决以上问题。
异步api代码如下：
runAsync() 异步无参返回
supplyAsync() 异步有参返回
allOf() 多个异步处理(针对有参返回)
anyOf() 多个异步随机处理(针对有参返回)
forEach循环
package cn.opendatachain.manage;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
/**
* SupplyAsyncTests Description
*
* @author lishijian
* @version odc-manage 1.0.0.RELEASE
* <b>Creation Time:</b> 2021/7/9 10:17
*/
@Slf4j
@SpringBootTest
public class SupplyAsyncTests {
/**
* runAsync() 异步无参返回
* @throws Exception
*/
@Test
public void asyncThread()throws Exception{
CompletableFuture async1 = CompletableFuture.runAsync(()->{
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName());
System.out.println("none return Async");
}catch (Exception e){
e.printStackTrace();
}
});
// 调用get()将等待异步逻辑处理完成
System.out.println("111111111111111111111111111111111");
async1.get();
System.out.println("222222222222222222222222222222222");
}
/**
* 输出结果：
*
* 111111111111111111111111111111111
* ForkJoinPool.commonPool-worker-19
* none return Async
* 222222222222222222222222222222222
*/
//----------------------------------------------------------------------------------------------------------------
/**
* supplyAsync() 异步有参返回
* @throws Exception
*/
@Test
public void asyncThread2()throws Exception{
CompletableFuture async2 = CompletableFuture.supplyAsync(()->{
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "hello";
});
System.out.println("111");
/**
* 最多等待这个未来的给定时间，如果完成返回结果，超时抛出TimeoutException
* get(timeout ,unit)
* @param timeout等待的最长时间
* @param unit超时参数的时间单位
*/
String result2 = (String)async2.get(3L, TimeUnit.SECONDS);
System.out.println("222");
//等待异步操作完成，然后返回其结果。
String result = (String)async2.get();
System.out.println("333");
System.out.println(result);
System.out.println(result2);
}
/**
* 输出结果：
* 111
* 222
* 333
* hello
* hello
*/
//----------------------------------------------------------------------------------------------------------------
/**
* allOf() 多个异步处理(针对有参返回)
* 注意：CompletableFuture 一定要给类型，否则无法识别
* @throws Exception
*/
@Test
public void asyncThread3()throws Exception{
CompletableFuture a = CompletableFuture.supplyAsync(() -> "hello");
CompletableFuture b = CompletableFuture.supplyAsync(() -> "youth");
CompletableFuture c = CompletableFuture.supplyAsync(() -> "!");
CompletableFuture all = CompletableFuture.allOf(a,b,c);
all.get();
String collect = Stream.of(a, b, c).map(CompletableFuture<String>::join).collect(Collectors.joining(" "));
System.out.println(collect);
}
/**
* 输出结果：
* hello youth !
*/
//----------------------------------------------------------------------------------------------------------------
/**
* anyOf() 多个异步随机处理(针对有参返回)
* @throws Exception
*/
@Test
public void asyncThread4()throws Exception{
CompletableFuture a = CompletableFuture.supplyAsync(() ->{
try{
Thread.sleep(20);
return "hello";
}catch (Exception e){
e.printStackTrace();
return "none~";
}
});
System.out.println("1111");
CompletableFuture b = CompletableFuture.supplyAsync(() -> "youth");
CompletableFuture c = CompletableFuture.supplyAsync(() -> "!");
CompletableFuture any = CompletableFuture.anyOf(a,b,c);
System.out.println("2222");
String result = (String)any.get();
System.out.println("3333");
System.out.println(result);
}
/**
* 输出结果：
* 1111
* 2222
* 3333
* youth
*/
//----------------------------------------------------------------------------------------------------------------
//forEach对List的循环样例
@Test
public void listForeach(){
List<String> lst = new ArrayList(5){{
add("A");
add("B");
add("H");
add("O");
add("M");
}};
lst.forEach(System.out::println);
lst.forEach((item)-> System.out.println(item.concat("_")));
}
//forEach对数组的循环 样例
@Test
public void arrForeach(){
String[] strArr = new String[]{"A","B","C","D"};
Arrays.stream(strArr).forEach(System.out::println);
}
//forEach对int范围的循环(包括头不包括尾) 样例
@Test
public void numericForeach(){
IntStream.range(0,10).forEach(System.out::println);
}
//forEach对Map的循环 样例:
@Test
public void mapForeach(){
Map<String,Object> mps = new HashMap(5){{
put("a",1);
put("b",true);
put("c",23.44F);
put("d","hello");
put("e",11L);
}};
mps.forEach((k,v)-> System.out.println(k.concat(":").concat(String.valueOf(v))));
}
}
