实际项目中使用CompletionService提升系统性能的一次实践
随着互联网应用的深入，很多传统行业也都需要接入到互联网。我们公司也是这样，保险核心需要和很多保险中介对接，比如阿里、京东等等。这些公司对于接口服务的性能有些比较高的要求，传统的核心无法满足要求，所以信息技术部领导高瞻远瞩，决定开发互联网接入服务，满足来自性能的需求。
概念
CompletionService将Executor和BlockingQueue的功能融合在一起，将Callable任务提交给CompletionService来执行，然后使用类似于队列操作的take和poll等方法来获得已完成的结果，而这些结果会在完成时被封装为Future。对于更多的概念，请参阅其他网络文档。
线程池的设计，阿里开发手册说过不要使用Java Executors 提供的默认线程池，因此需要更接近实际的情况来自定义一个线程池，根据多次压测，采用的线程池如下：
public ExecutorService getThreadPool(){
return new ThreadPoolExecutor(75,
125,
180000,
TimeUnit.MILLISECONDS,
new LinkedBlockingDeque<>(450),
new ThreadPoolExecutor.CallerRunsPolicy());
}
说明：公司的业务为低频交易，对于单次调用性能要求高，但是并发压力根本不大，所以 阻塞队列已满且线程数达到最大值时所采取的饱和策略为调用者执行。
实现
业务
投保业务主要涉及这几个大的方面：投保校验、核保校验、保费试算
投保校验：最主要的是要查询客户黑名单和风险等级，都是千万级的表。而且投保人和被保人都需要校验
核保校验：除了常规的核保规则校验，查询千万级的大表，还需要调用外部智能核保接口获得用户的风险等级，投保人和被保人都需要校验
保费试算：需要计算每个险种的保费
设计
根据上面的业务，如果串行执行的话，单次性能肯定不高，所以考虑多线程异步执行获得校验结果，再对结果综合判断
投保校验：采用一个线程(也可以根据投保人和被保人数量来采用几个线程)
核保校验：
常规校验：采用一个线程
外部调用：有几个用户(指投保人和被保人)就采用几个线程
保费计算：有几个险种就采用几个线程，最后合并得到整个的保费
代码
以下代码是样例，实际逻辑已经去掉
先创建投保、核保（常规、外部调用）、保费计算4个业务服务类：
投保服务类：InsuranceVerificationServiceImpl，假设耗时50ms
@Service
public class InsuranceVerificationServiceImpl implements InsuranceVerificationService {
private static final Logger logger = LoggerFactory.getLogger(InsuranceVerificationServiceImpl.class);
@Override
public TaskResponseModel<Object> insuranceCheck(String key, PolicyModel policyModel) {
try {
//假设耗时50ms
Thread.sleep(50);
return TaskResponseModel.success().setKey(key).setData(policyModel);
} catch (InterruptedException e) {
logger.warn(e.getMessage());
return TaskResponseModel.failure().setKey(key).setResultMessage(e.getMessage());
}
}
}
核保常规校验服务类：UnderwritingCheckServiceImpl，假设耗时50ms
@Service
public class UnderwritingCheckServiceImpl implements UnderwritingCheckService {
private static final Logger logger = LoggerFactory.getLogger(UnderwritingCheckServiceImpl.class);
@Override
public TaskResponseModel<Object> underwritingCheck(String key, PolicyModel policyModel) {
try {
//假设耗时50ms
Thread.sleep(50);
return TaskResponseModel.success().setKey(key).setData(policyModel);
} catch (InterruptedException e) {
logger.warn(e.getMessage());
return TaskResponseModel.failure().setKey(key).setResultMessage(e.getMessage());
}
}
}
核保外部调用服务类：ExternalCallServiceImpl，假设耗时200ms
@Service
public class ExternalCallServiceImpl implements ExternalCallService {
private static final Logger logger = LoggerFactory.getLogger(ExternalCallServiceImpl.class);
@Override
public TaskResponseModel<Object> externalCall(String key, Insured insured) {
try {
//假设耗时200ms
Thread.sleep(200);
ExternalCallResultModel externalCallResultModel = new ExternalCallResultModel();
externalCallResultModel.setIdcard(insured.getIdcard());
externalCallResultModel.setScore(200);
return TaskResponseModel.success().setKey(key).setData(externalCallResultModel);
} catch (InterruptedException e) {
logger.warn(e.getMessage());
return TaskResponseModel.failure().setKey(key).setResultMessage(e.getMessage());
}
}
}
试算服务类：TrialCalculationServiceImpl，假设耗时50ms
@Service
public class TrialCalculationServiceImpl implements TrialCalculationService {
private static final Logger logger = LoggerFactory.getLogger(TrialCalculationServiceImpl.class);
@Override
public TaskResponseModel<Object> trialCalc(String key, Risk risk) {
try {
//假设耗时50ms
Thread.sleep(50);
return TaskResponseModel.success().setKey(key).setData(risk);
} catch (InterruptedException e) {
logger.warn(e.getMessage());
return TaskResponseModel.failure().setKey(key).setResultMessage(e.getMessage());
}
}
}
统一返回接口类：TaskResponseModel， 上面4个服务的方法统一返回TaskResponseModel
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@Accessors(chain = true)
public class TaskResponseModel<T extends Object> implements Serializable {
private String key; //唯一调用标志
private String resultCode; //结果码
private String resultMessage; //结果信息
private T data; //业务处理结果
public static TaskResponseModel<Object> success() {
TaskResponseModel<Object> taskResponseModel = new TaskResponseModel<>();
taskResponseModel.setResultCode("200");
return taskResponseModel;
}
public static TaskResponseModel<Object> failure() {
TaskResponseModel<Object> taskResponseModel = new TaskResponseModel<>();
taskResponseModel.setResultCode("400");
return taskResponseModel;
}
}
注：
key为这次调用的唯一标识，由调用者传进来
resultCode结果码，200为成功，400表示有异常
resultMessage信息，表示不成功或者异常信息
data业务处理结果，如果成功的话
这些服务类都是单例模式
要使用用CompletionService的话，需要创建实现了Callable接口的线程
投保Callable:
@Data
@AllArgsConstructor
public class InsuranceVerificationCommand implements Callable<TaskResponseModel<Object>> {
private String key;
private PolicyModel policyModel;
private final InsuranceVerificationService insuranceVerificationService;
@Override
public TaskResponseModel<Object> call() throws Exception {
return insuranceVerificationService.insuranceCheck(key, policyModel);
}
}
核保常规校验Callable:
@Data
@AllArgsConstructor
public class UnderwritingCheckCommand implements Callable<TaskResponseModel<Object>> {
private String key;
private PolicyModel policyModel;
private final UnderwritingCheckService underwritingCheckService;
@Override
public TaskResponseModel<Object> call() throws Exception {
return underwritingCheckService.underwritingCheck(key, policyModel);
}
}
核保外部调用Callable:
@Data
@AllArgsConstructor
public class ExternalCallCommand implements Callable<TaskResponseModel<Object>> {
private String key;
private Insured insured;
private final ExternalCallService externalCallService;
@Override
public TaskResponseModel<Object> call() throws Exception {
return externalCallService.externalCall(key, insured);
}
}
试算调用Callable:
@Data
@AllArgsConstructor
public class TrialCalculationCommand implements Callable<TaskResponseModel<Object>> {
private String key;
private Risk risk;
private final TrialCalculationService trialCalculationService;
@Override
public TaskResponseModel<Object> call() throws Exception {
return trialCalculationService.trialCalc(key, risk);
}
}
注：
每一次调用，需要创建这4种Callable
返回统一接口TaskResopnseModel
异步执行的类：TaskExecutor
@Component
public class TaskExecutor {
private static final Logger logger = LoggerFactory.getLogger(TaskExecutor.class);
//线程池
private final ExecutorService executorService;
public TaskExecutor(ExecutorService executorService) {
this.executorService = executorService;
}
//异步执行，获取所有结果后返回
public List<TaskResponseModel<Object>> execute(List<Callable<TaskResponseModel<Object>>> commands) {
//创建异步执行对象
CompletionService<TaskResponseModel<Object>> completionService = new ExecutorCompletionService<>(executorService);
for (Callable<TaskResponseModel<Object>> command : commands) {
completionService.submit(command);
}
//获取所有异步执行线程的结果
int taskCount = commands.size();
List<TaskResponseModel<Object>> params = new ArrayList<>(taskCount);
try {
for (int i = 0; i < taskCount; i++) {
Future<TaskResponseModel<Object>> future = completionService.take();
params.add(future.get());
}
} catch (InterruptedException | ExecutionException e) {
//异常处理
params.clear();
params.add(TaskResponseModel.failure().setKey("error").setResultMessage("异步执行线程错误"));
}
//返回，如果执行中发生error, 则返回相应的key值：error
return params;
}
}
注：
为单例模式
接收参数为List<Callable<TaskResponseModel<Object>>>，也就是上面定义的4种Callable的列表
返回List<TaskResponseModel<Object>>，也就是上面定义4种Callable返回的结果列表
我们的业务是对返回结果统一判断，业务返回结果有因果关系
如果线程执行有异常，也返回List<TaskResponseModel>，这个时候列表中只有一个TaskResponseModel，key为error, 后续调用者可以通过这个来判断线程是否执行成功；
调用方：CompletionServiceController
@RestController
public class CompletionServiceController {
//投保key
private static final String INSURANCE_KEY = "insurance_";
//核保key
private static final String UNDERWRITING_KEY = "underwriting_";
//外部调用key
private static final String EXTERNALCALL_KEY = "externalcall_";
//试算key
private static final String TRIA_KEY = "trial_";
private static final Logger logger = LoggerFactory.getLogger(CompletionServiceController.class);
private final ExternalCallService externalCallService;
private final InsuranceVerificationService insuranceVerificationService;
private final TrialCalculationService trialCalculationService;
private final UnderwritingCheckService underwritingCheckService;
private final TaskExecutor taskExecutor;
public CompletionServiceController(ExternalCallService externalCallService, InsuranceVerificationService insuranceVerificationService, TrialCalculationService trialCalculationService, UnderwritingCheckService underwritingCheckService, TaskExecutor taskExecutor) {
this.externalCallService = externalCallService;
this.insuranceVerificationService = insuranceVerificationService;
this.trialCalculationService = trialCalculationService;
this.underwritingCheckService = underwritingCheckService;
this.taskExecutor = taskExecutor;
}
//多线程异步并发接口
@PostMapping(value = "/async", headers = "Content-Type=application/json;charset=UTF-8")
public String asyncExec(@RequestBody PolicyModel policyModel) {
long start = System.currentTimeMillis();
asyncExecute(policyModel);
logger.info("异步总共耗时：" + (System.currentTimeMillis() - start));
return "ok";
}
//串行调用接口
@PostMapping(value = "/sync", headers = "Content-Type=application/json;charset=UTF-8")
public String syncExec(@RequestBody PolicyModel policyModel) {
long start = System.currentTimeMillis();
syncExecute(policyModel);
logger.info("同步总共耗时：" + (System.currentTimeMillis() - start));
return "ok";
}
private void asyncExecute(PolicyModel policyModel) {
List<Callable<TaskResponseModel<Object>>> baseTaskCallbackList = new ArrayList<>();
//根据被保人外部接口调用
for (Insured insured : policyModel.getInsuredList()) {
ExternalCallCommand externalCallCommand = new ExternalCallCommand(EXTERNALCALL_KEY + insured.getIdcard(), insured, externalCallService);
baseTaskCallbackList.add(externalCallCommand);
}
//投保校验
InsuranceVerificationCommand insuranceVerificationCommand = new InsuranceVerificationCommand(INSURANCE_KEY, policyModel, insuranceVerificationService);
baseTaskCallbackList.add(insuranceVerificationCommand);
//核保校验
UnderwritingCheckCommand underwritingCheckCommand = new UnderwritingCheckCommand(UNDERWRITING_KEY, policyModel, underwritingCheckService);
baseTaskCallbackList.add(underwritingCheckCommand);
//根据险种进行保费试算
for(Risk risk : policyModel.getRiskList()) {
TrialCalculationCommand trialCalculationCommand = new TrialCalculationCommand(TRIA_KEY + risk.getRiskcode(), risk, trialCalculationService);
baseTaskCallbackList.add(trialCalculationCommand);
}
List<TaskResponseModel<Object>> results = taskExecutor.execute(baseTaskCallbackList);
for (TaskResponseModel<Object> t : results) {
if (t.getKey().equals("error")) {
logger.warn("线程执行失败");
logger.warn(t.toString());
}
logger.info(t.toString());
}
}
private void syncExecute(PolicyModel policyModel) {
//根据被保人外部接口调用
for (Insured insured : policyModel.getInsuredList()) {
TaskResponseModel<Object> externalCall = externalCallService.externalCall(insured.getIdcard(), insured);
logger.info(externalCall.toString());
}
//投保校验
TaskResponseModel<Object> insurance = insuranceVerificationService.insuranceCheck(INSURANCE_KEY, policyModel);
logger.info(insurance.toString());
//核保校验
TaskResponseModel<Object> underwriting = underwritingCheckService.underwritingCheck(UNDERWRITING_KEY, policyModel);
logger.info(underwriting.toString());
//根据险种进行保费试算
for(Risk risk : policyModel.getRiskList()) {
TaskResponseModel<Object> risktrial = trialCalculationService.trialCalc(risk.getRiskcode(), risk);
logger.info(risktrial.toString());
}
}
}
注：
1.为测试方便，提供两个接口调用：一个是串行执行，一个是异步并发执行
2.在异步并发执行函数asyncExecute中：
根据有多少个被保人，创建多少个外部调用的Callable实例，key值为EXTERNALCALL_KEY + insured.getIdcard()，在一次保单投保调用中，每一个被保人Callable的key是不一样的。
根据有多少个险种，创建多少个试算的Callable实例，key为TRIA_KEY + risk.getRiskcode()，在一次保单投保调用中，每一个险种的Callable的key是不一样的
创建投保校验的Callable实例，业务上只需要一个
创建核保校验的Callable实例，业务上只需要一个
将Callable列表传入到TaskExecutor执行异步并发调用
根据返回结果来判断，通过判断返回的TaskResponseModel的key值可以知道是哪类业务校验，分别进行判断，还可以交叉判断（公司的业务就是要交叉判断）
验证
验证数据：
{
"insuredList":
[{"idcard":"laza","name":"320106"},
{"idcard":"ranran","name":"120102"}],
"policyHolder":"lazasha","policyNo":"345000987","riskList":
[{"mainFlag":1,"premium":300,"riskcode":"risk001","riskname":"险种一"},
{"mainFlag":0,"premium":400,"riskcode":"risk002","riskname":"险种二"}]
}
上面数据表明：有两个被保人，两个险种。按照我们上面的定义，会调用两次外部接口，两次试算，一次投保，一次核保。而在样例代码中，一次外部接口调用耗时为200ms, 其他都为50ms.
本地开发的配置为8C16G:
同步串行接口调用计算：2 * 200 + 2 * 50 + 50 + 50 = 600ms
多线程异步执行调用计算：按照多线程并发执行原理，取耗时最长的200ms
验证：同步接口
输出耗时：可以看到耗时601ms
验证：多线程异步执行接口
输出耗时：可以看到为204ms
结果：基本和我们的预期相符合。
结束
这是将实际生产中的例子简化出来，具体生产的业务比较复杂，不便于展示。
实际情况下，原来的接口需要1000ms以上才能完成单次调用，有的需要2000-3000ms。现在的接口，在生产两台8c16g的虚拟机, 经过4个小时的简单压测能够支持2000用户并发，单次返回时长为350ms左右，服务很稳定，完全能够满足公司的业务发展需求。
实际项目中使用CompletionService提升系统性能的一次实践的更多相关文章
- 异步并发利器：实际项目中使用CompletionService提升系统性能的一次实践
场景 随着互联网应用的深入,很多传统行业也都需要接入到互联网.我们公司也是这样,保险核心需要和很多保险中介对接,比如阿里.京东等等.这些公司对于接口服务的性能有些比较高的要求,传统的核心无法满足要求, ...
- 我是如何在公司项目中使用ESLint来提升代码质量的
ESLint:你认识我吗 ESLint是一个语法规则和代码风格的检查工具. 和学习所有编程语言一样,想要入门ESLint,首先要去它的官网看看:https://eslint.org/. ESLint的 ...
- DotNet项目中的一些常用验证操作
在项目中需要对用户输入的信息,以及一些方法生成的结果进行验证,一般在项目中较多的采用js插件或js来进行有关信息的校验,但是从项目安全性的角度进行考虑,可对系统进行js注入. 如果在后台对用户输入的信 ...
- 记一次项目中的css样式复用
本文同步至微信公众号:http://mp.weixin.qq.com/s?__biz=MzAxMzgwNDU3Mg==&mid=401616238&idx=1&sn=3c6e9 ...
- 项目中的web api知识总结
最近在做公司的项目,自己负责webapi的框架的搭建与开发,最近很忙,一直没时间对工作中遇到的知识点缺少个总结,现总结一下,对自己是个提升,如果个人的小点点小总结能对博友有帮助那也是善莫大焉. (1) ...
- 简述MVC框架模式以及在你（Android）项目中的应用
标题是阿里电话面试的问题,一直以为自己很清楚MVC模式,结果被问到时,居然没法将MVC和Android中各个组件对应起来,所以,面试肯定挂了,不过面试也是学习的一种方式,可以知道大公司看中什么,以及自 ...
- 动端逐渐出了许多的移动端的框架，比如Sencha Touch、JQTouch、Jquery-moblie、jqMobi等等。这些框架都有优缺点，不同的框架应用在不同的项目中。现简单阐述一下各框架的优缺点：
移动前端工作的那些事---前端制作之微信小技巧篇 (2013-11-15 15:20) 转载▼ 标签: it css3/javascript html5 webapp 手机网站搭建 分类: 前端制 ...
- Python+Selenium进行UI自动化测试项目中，常用的小技巧1：读取excel表，转化成字典（dict）输出
从今天开始我将会把在项目中遇到的问题,以及常用的一些技巧来分享出来,以此来促进自己的学习和提升自己:更加方便我以后的查阅. 现在要说的是:用Python来读取excel表的数据,返回字典(dict), ...
- NIO提升系统性能
前言 在软件系统中,I/O的速度要比内存的速度慢很多,因此I/O经常会称为系统的瓶颈.所有,提高I/O速度,对于提升系统的整体性能有很大的作用. 在java标准的I/O中,是基于流的I/O的实现,即I ...
随机推荐
- HDU-2010.水仙花数（C语言描述）
Problem Description 春天是鲜花的季节,水仙花就是其中最迷人的代表,数学上有个水仙花数,他是这样定义的: "水仙花数"是指一个三位数,它的各位数字的立方和 ...
- Redis内存分析工具之redis-rdb-tools的安装与使用
操作系统:Centos7 1.redis-rdb-tools工具是用python语言编写的,所以首先需要安装python: 安装: (1)用 wget 下载 python 2.7 并解压( 如果 ...
- redis的使用场景和优缺点
使用场景和优缺点: 2 Redis用来做什么? 通常局限点来说,Redis也以消息队列的形式存在,作为内嵌的List存在,满足实时的高并发需求.而通常在一个电商类型的数据处理过程之中,有关商品,热销, ...
- 【Java】代码块
代码块 代码块的作用:用来初始化类.对象 代码块如果有修饰的话,只能使用static 分类:静态代码块.非静态代码块 静态代码块 static{ } 内部可以有输出语句 随着类的加载而执行,而且只执行 ...
- Android官方文档翻译 一 Getting Started
Getting Started 让我们开始吧! Welcome to Training for Android developers. 欢迎来到Android开发者训练营. Here you'll f ...
- 手把手教你分析解决MySQL死锁问题
在生产环境中如果出现MySQL死锁问题该如何排查和解决呢,本文将模拟真实死锁场景进行排查,最后总结下实际开发中如何尽量避免死锁发生. 一.准备好相关数据和环境 当前自己的数据版本是8.0.22 mys ...
- 【解决了一个小问题】vmselect对应的vmstorage端口配置错误导致的问题
从vmselect查询的时候,出现如下错误: error when executing query="up" on the time range (start=1639388706 ...
- selenium获取cookies并持久化登陆
selenium获取cookies并持久化登陆 需求背景: 这几天需要写一个接口,用来批量上传数据,最开始考虑的是 UI 自动化,然后选值的时候自动化难以判别,最终选择 接口 自动化. 然后操 ...
- Servlet Cookie的使用
HTTP(超文本传输协议)是一个基于请求与响应模式的无状态协议.无状态主要指 2 点: 协议对于事务处理没有记忆能力,服务器不能自动维护用户的上下文信息,无法保存用户状态: 每次请求都是独立的,不会受 ...
- gorm链接mysql的初始化配置和连接池的使用
1. mysql的初始化配置 dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?%s", user, passwd, host, port, db, ...