CompletableFuture多线程批量异步处理
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class DemoTest {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(4, 5, 3000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5));
List<Integer> ids = new ArrayList<>();
ids.add(1);
ids.add(2);
ids.add(3);
CompletableFuture<Integer>[] completableFutures = ids.stream().map(id -> {
return CompletableFuture.supplyAsync(() -> getNewId(id), threadPoolExecutor);
}).toArray(CompletableFuture[]::new);
CompletableFuture.allOf(completableFutures).join();
for (CompletableFuture<Integer> completableFuture : completableFutures) {
try {
System.out.println(completableFuture.get());
} catch (Exception e) {
e.printStackTrace();
}
}
return;
}
public static int getNewId(int id) {
return id + 3;
}
}
定时任务批处理
public class OrderManualPushJob {
@Autowired
private HotelOrderManualPushServie hotelOrderManualPushServie;
@Resource(name ="asyncOrderPushServiceExecutor")
private ExecutorService asyncExecutor;
@Override
public void veExecute(ShardingContext shardingContext) {
long t0 = System.currentTimeMillis();
List<OrderManualPush> orderManualPushList = hotelOrderManualPushServie.selectUnhandleList();
if(CollectionUtils.isEmpty(orderManualPushList)){
return;
}
long t1 = System.currentTimeMillis();
int perCount = 100;
List<List<OrderManualPush>> partitions = Lists.partition(orderManualPushList, perCount);
logger.info("批量处理多线程开始,本次处理的订单数量:{}",orderManualPushList.size());
logger.info("多线程数量:{}",partitions.size());
List<CompletableFuture> futures = Lists.newArrayList();
for(List<OrderManualPush> dataList : partitions){
List<OrderManualPush> finalDataList = dataList;
CompletableFuture<List<OrderManualPush>> future = CompletableFuture.supplyAsync(() -> pushOrder(finalDataList),asyncExecutor);
futures.add(future);
}
CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()])).join();
long t2 = System.currentTimeMillis();
logger.info("批量处理多线程结束,总耗时:{}ms",t2 - t1);
List<OrderManualPush> updateList = new ArrayList<>();
futures.stream().forEach(future->{
try {
List<OrderManualPush> list = (List<OrderManualPush>) future.get();
if(CollectionUtils.isNotEmpty(list)){
updateList.addAll(list);
}
}catch (Exception e){
logger.error("获取多线程返回结果数据异常",e);
}
});
hotelOrderManualPushServie.updateBatchList(updateList);
}
private List<OrderManualPush> pushOrder(List<OrderManualPush> dataList){
logger.info("当前线程:{},处理数据量:{},开始时间{}",Thread.currentThread().getName(),dataList.size(),System.currentTimeMillis());
List<OrderManualPush> updateList = Lists.newArrayList();
for (OrderManualPush order : dataList){
OrderManualPush updateBean = BeanMapper.map(order,OrderManualPush.class);
try {
hotelZjbService.datafz(order.getDdbh(),order.getDdlx(),new FcmqBody());
updateBean.setState("1");
}catch (Exception e){
updateBean.setState("2");
}
updateBean.setUpdateTime(VeDate.getNow());
updateList.add(updateBean);
}
logger.info("当前线程:{},处理数据量:{},结束时间{}",Thread.currentThread().getName(),dataList.size(),System.currentTimeMillis());
return updateList;
}
}