CompletionService提升系统性能的一次实践

最新推荐文章于 2023-07-10 06:05:09 发布
最新推荐文章于 2023-07-10 06:05:09 发布
阅读量232 收藏
点赞数
文章标签： 多线程 java
原文链接：https://www.cnblogs.com/javazhiyin/p/12336838.html
版权

1. 场景

随着互联网应用的深入，很多传统行业也都需要接入到互联网。我们公司也是这样，保险核心需要和很多保险中介对接，比如阿里、京东等等。这些公司对于接口服务的性能有些比较高的要求，传统的核心无法满足要求，所以信息技术部领导高瞻远瞩，决定开发互联网接入服务，满足来自性能的需求。

2. 概念

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());
      }

说明：公司的业务为低频交易，对于单次调用性能要求高，但是并发压力根本不大，所以 阻塞队列已满且线程数达到最大值时所采取的饱和策略为调用者执行。

3. 实现

3.1 业务

投保业务主要涉及这三个大的方面：投保校验、核保校验、保费试算。

投保校验

  • 投保校验：最主要的是要查询客户黑名单和风险等级，都是千万级的表。而且投保人和被保人都需要校验

投保校验

  • 核保校验：除了常规的核保规则校验，查询千万级的大表，还需要调用外部智能核保接口获得用户的风险等级，投保人和被保人都需要校验

保费试算

  • 保费试算：需要计算每个险种的保费

3.2 设计

根据上面的业务，如果串行执行的话，单次性能肯定不高，所以考虑多线程异步执行获得校验结果，再对结果综合判断

  • 投保校验：采用一个线程(也可以根据投保人和被保人数量来采用几个线程)
  • 核保校验：
    • 常规校验：采用一个线程
    • 外部调用：有几个用户(指投保人和被保人)就采用几个线程
  • 保费计算：有几个险种就采用几个线程，最后合并得到整个的保费

3.3 代码

以下代码是样例，实际逻辑已经去掉

先创建投保、核保（常规、外部调用）、保费计算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;
  }
}

注意：

  1. key为这次调用的唯一标识，由调用者传进来
  2. resultCode结果码，200为成功，400表示有异常
  3. resultMessage信息，表示不成功或者异常信息
  4. data业务处理结果，如果成功的话
  5. 这些服务类都是单例模式

要使用用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);
	}
}

注意：

  1. 每一次调用，需要创建这4种Callable
  2. 返回统一接口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;
  }
}

注意：

  1. 为单例模式
  2. 接收参数为List<Callable<TaskResponseModel>>，也就是上面定义的4种Callable的列表
  3. 返回List<TaskResponseModel>，也就是上面定义4种Callable返回的结果列表
  4. 我们的业务是对返回结果统一判断，业务返回结果有因果关系
  5. 如果线程执行有异常，也返回List，这个时候列表中只有一个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中：

    2.1 根据有多少个被保人，创建多少个外部调用的Callable实例，key值为EXTERNALCALL_KEY + insured.getIdcard()，在一次保单投保调用中，每一个被保人Callable的key是不一样的。

    2.2 根据有多少个险种，创建多少个试算的Callable实例，key为TRIA_KEY + risk.getRiskcode()，在一次保单投保调用中，每一个险种的Callable的key是不一样的

    2.3 创建投保校验的Callable实例，业务上只需要一个

    2.4 创建核保校验的Callable实例，业务上只需要一个

    2.5 将Callable列表传入到TaskExecutor执行异步并发调用

    2.6 根据返回结果来判断，通过判断返回的TaskResponseModel的key值可以知道是哪类业务校验，分别进行判断，还可以交叉判断（公司的业务就是要交叉判断）

4. 验证

验证数据：

{
"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
在这里插入图片描述
结果：基本和我们的预期相符合。

5. 结束

这是将实际生产中的例子简化出来，具体生产的业务比较复杂，不便于展示。

实际情况下，原来的接口需要1000ms以上才能完成单次调用，有的需要2000-3000ms。现在的接口，在生产两台8c16g的虚拟机, 经过4个小时的简单压测能够支持2000用户并发，单次返回时长为350ms左右，服务很稳定，完全能够满足公司的业务发展需求。

提供的这个是可以运行的列子，代码在

提供的这个是可以运行的列子，代码在：https://github.com/lazasha111211/completionservice-demo.git
参考链接

飞翔的企鹅01
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java并发编程系列之二十八：CompletionService
rhwayfun专栏
04-10 1万+
CompletionService简介CompletionService与ExecutorService类似都可以用来执行线程池的任务，ExecutorService继承了Executor接口，而CompletionService则是一个接口，那么为什么CompletionService不直接继承Executor接口呢？主要是Executor的特性决定的，Executor框架不能完全保证任务执行的异
CompletionService详解
qq_40276626的博客
08-27 7000
当我们有批量执行多个异步任务的业务，并且需要调用get()获取执行结果的时候，我们写的代码一般如下： Future f1 = excutor.submit(c1); f1.get(); Future f2 = excutor.submit(c2); f2.get(); f1.get()在获取成功之前会被阻塞，会阻塞c2的执行，严重降低了效率。 这时我们可以通过CompletionService来解决这一问题！ CompletionService结构 CompletionSerive接口有一个实现类Exe
Future & CompletionService 的使用（性能优化实战）
个人站点：javatv.net
04-08 1070
创建线程的方式 创建线程的方式一般有如下 4 种： 继承 Thread 类 实现 Runable 接口 实现 Callable 接口 利用线程池 其中，直接继承 Thread 或者实现 Runnable 接口都可以创建线程，但是这两种方法都有一个问题就是：没有返回值，也就是不能获取执行完的结果。因此 java1.5 就提供了 Callable 接口来实现这一场景，配合 Future 和 FutureTask 使用。 为什么需要 Callable？Runnable 的缺陷如下： 不能返回一个返回值 不能
CompletionService的基本使用以及原理
qq_39939541的博客
07-10 1861
CompletionService是Java并发编程中的一个工具类，它实现了一个任务完成的队列，并且可以按照任务完成的顺序来获取任务的结果。CompletionService的主要作用是提供一种方式来处理一批并发执行的任务，并且在它们完成后按照完成的顺序获取结果。它通常与ExecutorService一起使用。使用CompletionService可以将一组任务提交给ExecutorService去执行，并且通过调用CompletionService的take()方法来获取已经完成的任务的结果。
CompletionService使用总结
汉南最後の読書人
04-04 3831
接口CompletionService的功能是以异步的方式一边生产新的任务，一边处理已完成任务的结果，这样可以将执行任务与处理任务分离开来进行处理。使用submit执行任务，使用take取得已完成的任务，并按照完成这些任务的时间顺序处理它们的结果。 1.CompletionService介绍 接口CompletionService的结构比较简洁，仅有一个实现类ExecutorCompletio...
Java高并发编程中CompletionService的使用及详细介绍-刘宇
刘宇的博客
08-19 7282
作者：刘宇。一、什么是CompletionService？二、ExecutorCompletionService中的方法1、构造方法2、submit方法3、take方法4、poll方法三、案例1、问题复现2、利用CompletionService解决问题一、什么是CompletionService？它是Java8的新增接口，它的实现类是ExecutorCompletionService。CompletionService会根据线程池中Task的执行结果按执行完成的先后顺序排序，任务先完成的可优先获取到。
ExecutorService与CompletionService对比详解.docx
07-02
通过CompletionService，我们可以更灵活地处理任务间的依赖关系，提高系统响应速度，是并发编程中一种重要的优化手段。在实际应用中，可以根据具体需求选择合适的工具，以实现最佳的性能和效率。
JAVA并发编程实践-线程执行-学习笔记
最新发布
07-21
CompletionService是一个高级的并发工具，它结合了Executor和BlockingQueue的功能，允许处理已完成的任务，而无需等待所有任务完成。这对于处理大量并发任务并需要及时处理已完成任务的场景非常有用。 为任务设置...
通过多线程任务处理大批量耗时业务并返回结果
11-16
在IT领域，多线程是解决高性能和高并发问题的关键技术之一。本示例着重讨论如何利用多线程处理大批量耗时业务并确保能够获取每...对于开发者来说，理解和掌握这些并发处理技术对于提升系统性能和优化代码质量至关重要。
【Java多线程-4】CompletionService详解
云深不知处
03-31 3997
CompletionService是一个接口，该接口只有一个实现类 ExecutorCompletionService，该类使用创建时提供的 Executor 对象（通常是线程池）来执行任务，然后将结果放入一个阻塞队列中。 // Linkedblockingqueue作为任务完成队列 ExecutorCompletionService(Executor executor) // 将所提...
并发包工具之 批量处理任务 CompletionService（异步）、CompletableFuture（回调）
weixin_41750142的博客
02-13 1799
批量处理任务 CompletionService（异步）、CompletableFuture（回调）
CompletionService使用及原理(源码分析)
在路上
06-25 804
从CompletionService介绍,优势分析,使用,原理到源码,到扩展源码,让你透透彻彻了解,掌握
Java-多线程-CompletionService(优先处理)
band_mmbx的博客
08-11 424
这里有个问题：因为我们会要按固定的顺序来遍历 Future 元素，而 get() 方法又是阻塞的，因此如果某个 Future 对象执行时间太长，会使得我们的遍历过程阻塞在该元素上，无法及时从后面早已完成的 Future 当中取得结果。java.util.concurrent.CompletionService 是对 ExecutorService 的一个功能增强封装，优化了获取异步操作结果的接口。这个 take() 方法返回的是最早完成的任务的结果，这个就解决了一个任务被另一个任务阻塞的问题。...
CompletionService使用与源码分析
皮球
02-09 198
CompletionService使用与源码分析
CompletionService用法demo
uestzengting的专栏
07-25 172
CompletionService相当于Executor加上BlockingQueue，使用场景为当子线程并发了一系列的任务以后，主线程需要实时地取回子线程任务的返回值并同时顺序地处理这些返回值，谁先返回就先处理谁。下面两个类的工作效果相同，一个使用了CompletionService，代码更简捷些，一个直接使用的Executort和BlockingQueue，更复杂一些。其实读Completio...
线程池——futuretask、CompletionService、CompletableFuture
m0_46598535的博客
06-25 2350
java
completionservice
05-09
CompletionService是Java中的一个接口，它提供了一种方便的方式来处理异步任务的结果。CompletionService接口可以让你将异步任务提交给一个线程池进行处理，并且在任务完成后立即返回任务的结果。你可以使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值