Arthas 调优 并发 java 记录一次大数据量接口优化过程

问题描述

记录一次大数据量接口优化过程。最近在优化一个大数据量的接口，是提供给安卓端APP调用的，因为安卓端没做分批次获取，接口的数据量也比较大，因为加载速度超过一两分钟，所以导致接口超时的异常，要让安卓APP分批次调用需要收取费用，所以只能先优化一下接口的速度。

分析问题

先使用阿里开源的监控工具Arthas来分析接口，Arthas 是一款线上监控诊断平台，可以实时查看应用 load、内存、gc、线程的状态信息，可以在不修改代码的情况，定位问题，分析接口耗时、传参、异常等情况，提高线上问题排查效率 找到对应的接口代码，使用Arthas的trace命令跟踪一下接口耗时情况，listOrder是对应方法名，skipJDKMethod是不打印jdk里面的方法

trace com.sample.order.orderServiceImpl listOrder -n 1 --skipJDKMethod

要筛选出响应时间大于1000毫秒的，可以使用如下命令

trace com.sample.order.orderServiceImpl listOrder '#cost > 1000' -n 1

通过Arthas就可以分析出一个接口方法里具体那个调用耗时，然后一层层分析即可，Arthas分析的接口大致如下，仅供参考

--[100.00% 3434.755668ms ] org.springframework.cglib.proxy.MethodInterceptor:intercept()

`---[100.00% 3434.620187ms ] cn.test.server.business.VisitorBusiness:getStaffList()

+---[0.00% 0.045431ms ] cn.test.client.dto.StaffListReqDto:getComId() #188

+---[0.00% 0.019135ms ] cn.core.common.utils.CoreUtils:isEmpty() #188

+---[0.00% 0.021816ms ] cn.hutool.core.date.DateUtil:timer() #192

+---[0.00% 0.019987ms ] com.google.common.base.Splitter:on() #194

+---[0.00% 0.005501ms ] cn.test.client.dto.StaffListReqDto:getComId() #194

+---[0.00% 0.026292ms ] com.google.common.base.Splitter:splitToList() #194

+---[0.00% 0.131507ms ] cn.hutool.core.convert.Convert:toInt() #195

+---[0.34% 11.668407ms ] cn.core.user.client.querier.SchoolQuerierService:findBySchoolId() #198

+---[0.00% 0.024199ms ] cn.hutool.core.date.TimeInterval:intervalRestart() #203

+---[0.02% 0.535107ms ] org.slf4j.Logger:info() #203

+---[2.66% 91.504718ms ] cn.core.user.client.querier.RelationQuerierService:queryUserByIdsAndRoleType() #206

+---[0.00% 0.019208ms ] com.google.common.collect.Lists:newArrayList() #206

+---[0.00% 0.01107ms ] cn.core.common.utils.CoreUtils:isEmpty() #207

+---[0.00% 0.013517ms ] cn.hutool.core.date.TimeInterval:intervalRestart() #211

+---[0.02% 0.532242ms ] org.slf4j.Logger:info() #211

+---[0.00% 0.016216ms ] cn.hutool.core.date.TimeInterval:intervalRestart() #218

+---[0.01% 0.435469ms ] org.slf4j.Logger:info() #218

+---[0.00% 0.009024ms ] cn.test.client.dto.StaffListReqDto:getComId() #221

+---[0.53% 18.336268ms ]cn.test.persistence.dao.LogMapper:listStaffSyncRecordByComId() #221

+---[0.00% 0.009043ms ] com.google.common.collect.Lists:newArrayList() #221

+---[0.00% 0.019237ms ] cn.hutool.core.date.TimeInterval:intervalRestart() #223

+---[0.01% 0.279834ms ] org.slf4j.Logger:info() #223

+---[0.00% 0.014057ms ] cn.hutool.core.date.TimeInterval:intervalRestart() #227

+---[0.01% 0.270155ms ] org.slf4j.Logger:info() #227

+---[0.00% 0.006338ms ] com.google.common.collect.Lists:newArrayList() #231

+---[0.00% 0.019707ms ] cn.hutool.core.date.TimeInterval:intervalRestart() #263

+---[0.02% 0.548875ms ] org.slf4j.Logger:info() #263

`---[0.00% 0.027475ms ] cn.test.client.dto.Result:success() #265

通过Arthas分析问题，定位到接口里，是因为查询出所有的数据后，再循环这些数据，在循环里又调了API去做业务处理，针对这种情况，怎么做调优？

处理问题

针对这种情况，我想到了分批次，分页来获取接口比较好，但是安卓端要改，需要收费额外的费用，所以我只能用多线程来做分批次处理了，JDK8里提供了CompletableFuture这个api来处理多任务，多线程，所以使用这个API加上线程池来处理接口

public OrderResult> getOrderList(ListReqDto reqDto) throws ExecutionException, InterruptedException {

if (CoreUtils.isEmpty(reqDto.getComId())) {

return OrderResult.fail("comId can not be null");

}

// Hutool计时器

TimeInterval timer = DateUtil.timer();

EmsReqVo reqVo = new EmsReqVo();

reqVo.setComId(reqDto.getComId());

List orderRecList = Optional.ofNullable(orderMapper.queryOrderRecVo(reqVo )).orElse(Lists.newArrayList());

LOG.info("查询所有预约订单:{}", timer.intervalRestart());

if (CollUtil.isEmpty(orderRecList )) {

return OrderResult.success(Lists.newArrayList());

}

// 任务列表

List> fList = new ArrayList<>();

// 自定义线程池

ExecutorService executor = new ThreadPoolExecutor(

10, 100, 5,

TimeUnit.MINUTES,

new ArrayBlockingQueue<>(10000)

);

List orderDtoList= Lists.newArrayList();

orderRecList.stream().forEach(v -> {

CompletableFuture f = CompletableFuture.supplyAsync(

()-> {

Long userId = v.getUserId;

// 根据userId去调用户数据，比较耗时

UserDto userDto = userService.selectOne(userId);

// 封装参数返回

OrderListDto orderListDto = OrderListDto.builder()

.code(generator(v.getId())) // 流水号

.name(v.getOwnerName()) // 预约人姓名

.sex(gender) // 预约人性别

.identity(v.getIdentityNum()) // 证件号码

.addr(v.getAddress()) // 证件地址

.tel(v.getMobile()) // 联系电话

.build();

return orderListDto;

},

executor

);

fList.add(f);

});

// 获取所有的任务

CompletableFuture all= CompletableFuture.allOf(fList.toArray(new CompletableFuture[0]));

CompletableFuture> allInfo = all.thenApply(v-> fList.stream().map(a-> {

try {

return a.get();

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

return null;

}).collect(Collectors.toList()));

// 返回list

orderDtoList= allInfo.get();

// 关闭线程池

executor.shutdown();

LOG.info("查询预约订单记录 use:{}", timer.intervalRestart());

return OrderResult.success(orderDtoList);

}

通过CompletableFuture多任务处理，接口速度提高都十几秒，ps：方便举例子，用了手动创建线程池，如果真实项目里建议用spring配置去管理线程池

所以需要继续调优，在循环里调api会有网络带宽的影响，所以改成通过userId的集合去获取所有数据，封装成一个map集合，在循环里调用

List userIds = orderRecList.stream().map(OrderRecVo::getReceiveId).collect(Collectors.toList());

List usersList = Optional.ofNullable(userService.getUsersByIds(userIds)).orElse(Lists.newArrayList());

Map usersMap = usersList.stream().collect(Collectors.toMap(UserDto::getId, u -> u));

在循环里再通过map获取即可

UserDto userDto = usersMap.getOrDefault(v.getUserId(), new UserDto ());

通过所有id集合获取总的所有数据，再通过map去获取的方式，接口速度快了很多，大概到毫秒级别

推荐链接

 您阅读本篇文章共花了：