什么是线程池
首先我们要知道 new线程是有开销的,在栈里面需要开辟空间,针对这种有限的宝贵的资源,我们不能无限的去创建线程,这时候就有一个大聪明提出了线程池这么一个概念了,线程池可以帮我么保管起来,不需要去管什么时候new线程,什么时候销毁和回收。我们只需要往线程池里面提交任务即可。
要维护线程池我们需要做哪些事情
核心线程数
等待队列(不宜设置过长一般几百个就可以了,过长容易OOM)
最大线程
拒绝策略
线程工厂
空闲线程等待时间
时间单位
提交任务的流程有哪些?
当任务提交到线程池中的时候,首先是利用核心线程,当核心线程满了,那他回去等待队列,当等待队列也满了,会利用最大线程,当最大线程也满了,这时候会触发拒绝策略了
拒绝策略有哪些?
1. 丢弃任务并抛出异常(默认的)
2.退回到主线程继续执行(常用的策略,防止任务丢失)
3.丢弃任务但是不抛出异常
4.丢弃最早的未执行的任务,重新执行任务
线程异常的处理方案有哪些?
1.手动try-cath,手动捕获异常,打印日志进行补偿
2.submin提交后,Feature.get()接收异常信息
多线程的实现方式有哪些?
继承Thread类(重写run方法)
实现runable接口
实现calable接口和Future接口(通过重写call方法,这个是有返回值的,表示多线程的运行结果Future 它可以管理多线程运行的结果)
// 创建一个类实现 Callable 接口,这里要注意,Callable需要传递一个泛型,表示运行的结果类型
public class Thread03 implements Callable<Integer> {
@Override
public Integer call() throws Exception {
// 随便写一段逻辑,求 1~100 的 整数和
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum = sum + i;
}
// 将计算的结果返回
return sum;
}
}
public class TestThread03 {
public static void main(String[] args) {
// 创建线程 Thread03的对象
Thread03 t1 = new Thread03();
// 将创建的 t1 对象作为参数传递给 FutureTask
FutureTask<Integer> futureTask = new FutureTask<>(t1);
// 创建 Thread 对象,并把 futureTask 作为参数的传递进去
Thread thread = new Thread(futureTask);
// 通过 start 启动线程
thread.start();
// 获取线程的结果,有异常使用 try。。。catch。。。
try {
Integer num = futureTask.get();
System.out.println(num);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
线程池代码真实业务场景展示(多线程实现批量导出)
public class ExportConcurrentlyThreadPool {
private final static String THREAD_IDENTIFICATION = "tfx-future-export-concurrently";
public static ExecutorService executorService;
static {
int availProcessors = Runtime.getRuntime().availableProcessors();
executorService = new TfxThreadPoolExecutor(availProcessors * 4, availProcessors * 4,
60, TimeUnit.SECONDS,
new LinkedBlockingDeque<>(300), new TfxThreadFactory(THREAD_IDENTIFICATION),
new ThreadPoolExecutor.CallerRunsPolicy());
}
}
public Result<String> exportSpBrandQualificationList(SpBrandQualificationQryReq spBrandQualificationQryReq) {
SpBrandQualificationQryParam param = new SpBrandQualificationQryParam();
BeanUtils.copyProperties(spBrandQualificationQryReq, param);
int pageSize = 100;
param.setPageSize(pageSize);
Long totalNum = spBrandQualificationFlowService.querySpBrandQualificationTotalNum(param);
if (totalNum <= 0) {
return Result.fail(ErrorCodeEnum.PARAM_INVALID.getCode(), "导出数据集为空");
}
if (totalNum > BrandQualificationSwitch.brandQualificationExportMaxLimit) {
return Result.fail(ErrorCodeEnum.PARAM_INVALID.getCode(), "导出数据量过大,请缩小查询条件");
}
List<SpBrandQualificationEO> qualificationEOS = new ArrayList<>(totalNum.intValue());
int pageCount = (int) Math.ceil(totalNum * 1.0 / pageSize);
List<CompletableFuture<List<SpBrandQualificationEO>>> futureTasks = new ArrayList<>(pageCount);
for (int pageIdx = 1; pageIdx <= pageCount; pageIdx++) {
SpBrandQualificationQryParam finalParam = new SpBrandQualificationQryParam();
BeanUtils.copyProperties(spBrandQualificationQryReq, finalParam);
finalParam.setPageSize(pageSize);
finalParam.setPageNo(pageIdx);
String traceId = EagleEye.getTraceId();
CompletableFuture<List<SpBrandQualificationEO>> future = CompletableFuture.supplyAsync(() -> {
try {
long start = System.currentTimeMillis();
List<SpBrandQualificationDTO> spBrandQualificationDTOS = spBrandQualificationFlowService.querySpBrandQualificationList(finalParam);
List<Long> spUserIds = spBrandQualificationDTOS.stream().map(SpBrandQualificationDTO::getSpUserId).collect(Collectors.toList());
Multimap<Long, UserSettleDTO> uSerSettleDTOS = getUserSettleDTOMap(spUserIds);
List<SpBrandQualificationEO> result = convert2EOList(spBrandQualificationDTOS, uSerSettleDTOS);
log.info("subList cost: {}, traceId={}", System.currentTimeMillis() - start, traceId);
return result;
} catch (Throwable throwable) {
log.error("exportSettleAuditList error, traceId={}", traceId, throwable);
return Lists.newArrayList();
}
}, ExportConcurrentlyThreadPool.executorService);
futureTasks.add(future);
}
try {
long start = System.currentTimeMillis();
CompletableFuture.allOf(futureTasks.toArray(new CompletableFuture[0])).get(12, TimeUnit.SECONDS);
log.info("wait cost: {}, traceId={} ", System.currentTimeMillis() - start, EagleEye.getTraceId());
for (CompletableFuture<List<SpBrandQualificationEO>> futureTask : futureTasks) {
List<SpBrandQualificationEO> result = futureTask.get();
qualificationEOS.addAll(result);
}
} catch (TimeoutException e) {
log.error("exportBrandQualificationList timeout", e);
return Result.fail(ErrorCodeEnum.SERVICE_TIME_OUT.getCode(), "导出超时,请缩小查询条件");
} catch (Exception e) {
log.error("exportBrandQualificationList error", e);
return Result.fail(ErrorCodeEnum.SERVER_ERROR.getCode(), "导出异常,请重试");
}
String fileName = "品牌资质审核列表_" + IddContext.getUserName() + "_" + DateUtil.formatDate(new Date(), "yyyyMMddHHmmss");
String url = excelHelper.publicExport(SpBrandQualificationEO.class, "供应商品牌资质审核数据", fileName,
(excelExportUtil) -> excelExportUtil.exportModel(qualificationEOS, SpBrandQualificationEO.class));
return Result.success(url);
}
CompletableFuture多线程任务编排
代码解读:
CompletableFuture<List<SpBrandQualificationEO>> future = CompletableFuture.supplyAsync(() ->
这段代码的作用是
1.启动一个异步任务去获取(可能是从数据库、远程服务等)一个对象列表;
2.这个操作不会阻塞当前的执行线程。
3. 当需要使用这些数据时,可以通过future
对象的其他方法(如thenApply
, thenAccept
, get
等)来处理或获取这个异步计算的结果
CompletableFuture.allOf(futureTasks.toArray(new CompletableFuture[0])).get(12, TimeUnit.SECONDS);
等待futureTasks
集合中的所有CompletableFuture
任务在最多12秒内全部完成。
如果所有任务都在12秒内完成,则.get(12, TimeUnit.SECONDS)
调用结束,程序继续执行。
如果有任何任务超过12秒未完成,则会抛出TimeoutException
。
这是一种控制异步操作整体超时的有效方式。
利用线程池异步调用第三方接口案例
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class AsyncThirdPartyApiCaller {
public static void main(String[] args) {
// 创建一个固定大小的线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
// 模拟需要异步调用的第三方API任务
Future<String> resultFuture = executorService.submit(() -> callThirdPartyApi("someData"));
// 主线程可以继续执行其他任务,不必等待resultFuture完成
// 以下代码为模拟主线程其他任务
System.out.println("主线程继续执行其他任务...");
// 如果需要,可以尝试获取结果,这将阻塞直到结果可用或发生异常
try {
String result = resultFuture.get(); // get() 方法可能会抛出InterruptedException, ExecutionException
System.out.println("第三方API调用结果: " + result);
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭线程池,不再接受新任务,已提交的任务会执行完毕
executorService.shutdown();
// 如果需要等待所有任务执行完毕再结束程序,可以使用 executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
}
}
/**
* 模拟调用第三方API的方法
* @param data 要发送给API的数据
* @return API响应数据
*/
private static String callThirdPartyApi(String data) {
// 这里应该是实际的API调用逻辑,例如使用HttpClient发送HTTP请求
// 为了示例,我们简单返回一个字符串
System.out.println("模拟调用第三方API with data: " + data);
try {
Thread.sleep(2000); // 模拟API调用耗时
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
return "API响应数据: " + data.toUpperCase();
}
}