获取双异步返回值时，如何保证主线程不阻塞？

最新推荐文章于 2024-05-11 10:24:57 发布
最新推荐文章于 2024-05-11 10:24:57 发布
阅读量926 收藏 23
点赞数 21
文章标签： java 前端 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2311/article/details/135853280
版权

一、前情提要

在上一篇文章中，使用双异步后，如何保证数据一致性？，通过Future获取异步返回值，轮询判断Future状态，如果执行完毕或已取消，则通过get()获取返回值，get()是阻塞的方法，因此会阻塞当前线程，如果通过new Runnable()执行get()方法，那么还是需要返回AsyncResult，然后再通过主线程去get()获取异步线程返回结果。

写法很繁琐，还会阻塞主线程。

下面是FutureTask异步执行流程图：

二、JDK8的CompletableFuture

1、ForkJoinPool

Java8中引入了CompletableFuture，它实现了对Future的全面升级，可以通过回调的方式，获取异步线程返回值。

CompletableFuture的异步执行通过ForkJoinPool实现， 它使用守护线程去执行任务。

ForkJoinPool在于可以充分利用多核CPU的优势，把一个任务拆分成多个小任务，把多个小任务放到多个CPU上并行执行，当多个小任务执行完毕后，再将其执行结果合并起来。

Future的异步执行是通过ThreadPoolExecutor实现的。

2、从ForkJoinPool和ThreadPoolExecutor探索CompletableFuture和Future的区别

  1. ForkJoinPool中的每个线程都会有一个队列，而ThreadPoolExecutor只有一个队列，并根据queue类型不同，细分出各种线程池；
  2. ForkJoinPool在使用过程中，会创建大量的子任务，会进行大量的gc，但是ThreadPoolExecutor不需要，因为ThreadPoolExecutor是任务分配平均的；
  3. ThreadPoolExecutor中每个异步线程之间是相互独立的，当执行速度快的线程执行完毕后，它就会一直处于空闲的状态，等待其它线程执行完毕；
  4. ForkJoinPool中每个异步线程之间并不是绝对独立的，在ForkJoinPool线程池中会维护一个队列来存放需要执行的任务，当线程自身任务执行完毕后，它会从其它线程中获取未执行的任务并帮助它执行，直至所有线程执行完毕。

因此，在多线程任务分配不均时，ForkJoinPool的执行效率更高。但是，如果任务分配均匀，ThreadPoolExecutor的执行效率更高，因为ForkJoinPool会创建大量子任务，并对其进行大量的GC，比较耗时。

三、通过CompletableFuture优化 “通过Future获取异步返回值”

1、通过Future获取异步返回值关键代码

（1）将异步方法的返回值改为Future<Integer>，将返回值放到new AsyncResult<>();中；
 

java
 

复制代码
 

@Async("async-executor") public void readXls(String filePath, String filename) { try { // 此代码为简化关键性代码 List<Future<Integer>> futureList = new ArrayList<>(); for (int time = 0; time < times; time++) { Future<Integer> sumFuture = readExcelDataAsyncFutureService.readXlsCacheAsync(); futureList.add(sumFuture); } }catch (Exception e){ logger.error("readXlsCacheAsync---插入数据异常：",e); } } 
 

 

java
 

复制代码
 

@Async("async-executor") public Future<Integer> readXlsCacheAsync() { try { // 此代码为简化关键性代码 return new AsyncResult<>(sum); }catch (Exception e){ return new AsyncResult<>(0); } } 
 

（2）通过Future<Integer>.get()获取返回值：
 

 

java
 

复制代码
 

public static boolean getFutureResult(List<Future<Integer>> futureList, int excelRow) { int[] futureSumArr = new int[futureList.size()]; for (int i = 0;i<futureList.size();i++) { try { Future<Integer> future = futureList.get(i); while (true) { if (future.isDone() && !future.isCancelled()) { Integer futureSum = future.get(); logger.info("获取Future返回值成功"+"----Future:" + future + ",Result:" + futureSum); futureSumArr[i] += futureSum; break; } else { logger.info("Future正在执行---获取Future返回值中---等待3秒"); Thread.sleep(3000); } } } catch (Exception e) { logger.error("获取Future返回值异常: ", e); } } boolean insertFlag = getInsertSum(futureSumArr, excelRow); logger.info("获取所有异步线程Future的返回值成功，Excel插入结果="+insertFlag); return insertFlag; } 
 

2、通过CompletableFuture获取异步返回值关键代码
 

（1）将异步方法的返回值改为 int
 

 

java
 

复制代码
 

@Async("async-executor") public void readXls(String filePath, String filename) { List<CompletableFuture<Integer>> completableFutureList = new ArrayList<>(); for (int time = 0; time < times; time++) { // 此代码为简化关键性代码 CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() { @Override public Integer get() { return readExcelDbJdk8Service.readXlsCacheAsyncMybatis(); } }).thenApply((result) -> {// 回调方法 return thenApplyTest2(result);// supplyAsync返回值 * 1 }).thenApply((result) -> { return thenApplyTest5(result);// thenApply返回值 * 1 }).exceptionally((e) -> { // 如果执行异常: logger.error("CompletableFuture.supplyAsync----异常：", e); return null; }); completableFutureList.add(completableFuture); } } 
 

 

java
 

复制代码
 

@Async("async-executor") public int readXlsCacheAsync() { try { // 此代码为简化关键性代码 return sum; }catch (Exception e){ return -1; } } 
 

（2）通过completableFuture.get()获取返回值
 

 

java
 

复制代码
 

public static boolean getCompletableFutureResult(List<CompletableFuture<Integer>> list, int excelRow){ logger.info("通过completableFuture.get()获取每个异步线程的插入结果----开始"); int sum = 0; for (int i = 0; i < list.size(); i++) { Integer result = list.get(i).get(); sum += result; } boolean insertFlag = excelRow == sum; logger.info("全部执行完毕，excelRow={}，入库={}, 数据是否一致={}",excelRow,sum,insertFlag); return insertFlag; } 
 

3、效率对比
 

（1）测试环境
 

  1. 12个逻辑处理器的电脑；
  2. Excel中包含10万条数据；
  3. Future的自定义线程池，核心线程数为24；
  4. ForkJoinPool的核心线程数为24；
 

（2）统计四种情况下10万数据入库时间
 

  1. 不获取异步返回值
  2. 通过Future获取异步返回值
  3. 通过CompletableFuture获取异步返回值，默认ForkJoinPool线程池的核心线程数为本机逻辑处理器数量，测试电脑为12；
  4. 通过CompletableFuture获取异步返回值，修改ForkJoinPool线程池的核心线程数为24。
 

备注：因为CompletableFuture不阻塞主线程，主线程执行时间只有2秒，表格中统计的是异步线程全部执行完成的时间。
 

（3）设置核心线程数
 

将核心线程数CorePoolSize设置成CPU的处理器数量，是不是效率最高的？
 

 

java
 

复制代码
 

// 获取CPU的处理器数量 int curSystemThreads = Runtime.getRuntime().availableProcessors() * 2;// 测试电脑是24 
 

因为在接口被调用后，开启异步线程，执行入库任务，因为测试机最多同时开启24线程处理任务，故将10万条数据拆分成等量的24份，也就是10万/24 = 4166，那么我设置成4200，是不是效率最佳呢？
 

测试的过程中发现，好像真的是这样的。
 

自定义ForkJoinPool线程池
 

 

java
 

复制代码
 

@Autowired @Qualifier("asyncTaskExecutor") private Executor asyncTaskExecutor; @Override public void readXls(String filePath, String filename) { List<CompletableFuture<Integer>> completableFutureList = new ArrayList<>(); for (int time = 0; time < times; time++) { CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() { @Override public Integer get() { try { return readExcelDbJdk8Service.readXlsCacheAsync(sheet, row, start, finalEnd, insertBuilder); } catch (Exception e) { logger.error("CompletableFuture----readXlsCacheAsync---异常：", e); return -1; } }; },asyncTaskExecutor); completableFutureList.add(completableFuture); } // 不会阻塞主线程 CompletableFuture.allOf(completableFutureList.toArray(new CompletableFuture[completableFutureList.size()])).whenComplete((r,e) -> { try { int insertSum = getCompletableFutureResult(completableFutureList, excelRow); } catch (Exception ex) { return; } }); } 
 

自定义线程池
 

 

java
 

复制代码
 

/** * 自定义异步线程池 */ @Bean("asyncTaskExecutor") public AsyncTaskExecutor asyncTaskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); //设置线程名称 executor.setThreadNamePrefix("asyncTask-Executor"); //设置最大线程数 executor.setMaxPoolSize(200); //设置核心线程数 executor.setCorePoolSize(24); //设置线程空闲时间，默认60 executor.setKeepAliveSeconds(200); //设置队列容量 executor.setQueueCapacity(50); /** * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略 * 通常有以下四种策略： * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程） * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功 */ executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); executor.initialize(); return executor; } 
 

 

 

（4）统计分析
 

效率对比：
 

③通过CompletableFuture获取异步返回值（12线程） < ②通过Future获取异步返回值 < ④通过CompletableFuture获取异步返回值（24线程） < ①不获取异步返回值
 

不获取异步返回值时性能最优，这不废话嘛~
 

核心线程数相同的情况下，CompletableFuture的入库效率要优于Future的入库效率，10万条数据大概要快4秒钟，这还是相当惊人的，优化的价值就在于此。
 

 

 

四、通过CompletableFuture.allOf解决阻塞主线程问题
 

1、语法
 

CompletableFuture.allOf(CompletableFuture的可变数组).whenComplete((r,e) -> {})。
 

2、代码实例
 

getCompletableFutureResult方法在 “3.2.2 通过completableFuture.get()获取返回值”。
 

 

java
 

复制代码
 

// 不会阻塞主线程 CompletableFuture.allOf(completableFutureList.toArray(new CompletableFuture[completableFutureList.size()])).whenComplete((r,e) -> { logger.info("全部执行完毕，解决主线程阻塞问题~"); try { int insertSum = getCompletableFutureResult(completableFutureList, excelRow); } catch (Exception ex) { logger.error("全部执行完毕，解决主线程阻塞问题，异常：", ex); return; } }); // 会阻塞主线程 //getCompletableFutureResult(completableFutureList, excelRow); logger.info("CompletableFuture----会阻塞主线程吗？"); 
 

 

 

五、CompletableFuture中花俏的语法糖
 

1、runAsync
 

runAsync 方法不支持返回值。
 

可以通过runAsync执行没有返回值的异步方法。
 

不会阻塞主线程。
 

 

java
 

复制代码
 

// 分批异步读取Excel内容并入库 int finalEnd = end; CompletableFuture.runAsync(() -> readExcelDbJdk8Service.readXlsCacheAsyncMybatis(); 
 

2、supplyAsync
 

supplyAsync也可以异步处理任务，传入的对象实现了Supplier接口。将Supplier作为参数并返回CompletableFuture结果值，这意味着它不接受任何输入参数，而是将result作为输出返回。
 

会阻塞主线程。
 

supplyAsync()方法关键代码：
 

 

java
 

复制代码
 

int finalEnd = end; CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() { @Override public Integer get() { return readExcelDbJdk8Service.readXlsCacheAsyncMybatis(); } }); 
 

 

java
 

复制代码
 

@Override public int readXlsCacheAsyncMybatis() { // 不为人知的操作 // 返回异步方法执行结果即可 return 100; } 
 

六、顺序执行异步任务
 

1、thenRun
 

thenRun()不接受参数，也没有返回值，与runAsync()配套使用，恰到好处。
 

 

java
 

复制代码
 

// JDK8的CompletableFuture CompletableFuture.runAsync(() -> readExcelDbJdk8Service.readXlsCacheAsyncMybatis()) .thenRun(() -> logger.info("CompletableFuture----.thenRun()方法测试")); 
 

 

 

2、thenAccept
 

thenAccept()接受参数，没有返回值。
 

supplyAsync + thenAccept
 

  1. 异步线程顺序执行
  2. supplyAsync的异步返回值，可以作为thenAccept的参数使用
  3. 不会阻塞主线程
 

 

java
 

复制代码
 

CompletableFuture.supplyAsync(new Supplier<Integer>() { @Override public Integer get() { return readExcelDbJdk8Service.readXlsCacheAsyncMybatis(); } }).thenAccept(x -> logger.info(".thenAccept()方法测试：" + x)); 
 

 

 

但是，此时无法通过completableFuture.get()获取supplyAsync的返回值了。
 

3、thenApply
 

thenApply在thenAccept的基础上，可以再次通过completableFuture.get()获取返回值。
 

supplyAsync + thenApply，典型的链式编程。
 

  1. 异步线程内方法顺序执行
  2. supplyAsync 的返回值，作为第 1 个thenApply的参数，进行业务处理
  3. 第 1 个thenApply的返回值，作为第 2 个thenApply的参数，进行业务处理
  4. 最后，通过future.get()方法获取最终的返回值
 

 

java
 

复制代码
 

CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() { @Override public Integer get() { return readExcelDbJdk8Service.readXlsCacheAsyncMybatis(); } }).thenApply((result) -> { return thenApplyTest2(result);// supplyAsync返回值 * 2 }).thenApply((result) -> { return thenApplyTest5(result);// thenApply返回值 * 5 }); logger.info("readXlsCacheAsyncMybatis插入数据 * 2 * 5 = " + completableFuture.get()); 
 

 

 

七、CompletableFuture合并任务
 

  1. thenCombine，多个异步任务并行处理，有返回值，最后合并结果返回新的CompletableFuture对象；
  2. thenAcceptBoth，多个异步任务并行处理，无返回值；
  3. acceptEither，多个异步任务并行处理，无返回值；
  4. applyToEither，，多个异步任务并行处理，有返回值；
 

CompletableFuture合并任务的代码实例，这里就不多赘述了，一些语法糖而已，大家切记陷入低水平勤奋的怪圈。
 

八、CompletableFuture VS Future总结
 

本文中以下几个方面对比了CompletableFuture和Future的差异：
 

  1. ForkJoinPool和ThreadPoolExecutor的实现原理，探索了CompletableFuture和Future的差异；
  2. 通过代码实例的形式简单介绍了CompletableFuture中花俏的语法糖；
  3. 通过CompletableFuture优化了 “通过Future获取异步返回值”；
  4. 通过CompletableFuture.allOf解决阻塞主线程问题。
 

Future提供了异步执行的能力，但Future.get()会通过轮询的方式获取异步返回值，get()方法还会阻塞主线程。
 

轮询的方式非常消耗CPU资源，阻塞的方式显然与我们的异步初衷背道而驰。
 

JDK8提供的CompletableFuture实现了Future接口，添加了很多Future不具备的功能，比如链式编程、异常处理回调函数、获取异步结果不阻塞不轮询、合并异步任务等。
 

获取异步线程结果后，我们可以通过添加事务的方式，实现Excel入库操作的数据一致性。
 

异步多线程情况下如何实现事务？
 

有的小伙伴可能会说：
 

这还不简单？添加@Transactional注解，如果发生异常或入库数据量不符，直接回滚就可以了~
 

那么，真的是这样吗？我们下期见~

                

        

        

        

    




    

      

        

            

              
                
                  程序一逸
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    21
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    23
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
获取JavaScript异步函数的返回值

				
			

			

				

					11-28
				

			

		

		

			
				
今天研究一个小问题： 怎么拿到JavaScript异步函数的返回值？
1.错误尝试
当年未入行时，我的最初尝试：

[removed]
function getSomething() {
 var r = 0;
 setTimeout(function() {
 r = 2;
 }, 10);
 return r;
}
function compute() {
 var x = getSomething();
 alert(x * 2);
}
compute();
[removed]

2.回调函数
弹出的不是4，而是0，后来知道这是异步的问题，
要用回调技术来做：

[removed]
func

			
		

	



                

              
                



	

		

			

				
					
Java多线程-FutureTask的get方法阻塞问题

				
			

			

				

					Leetp
				

				

					04-27
					
					1万+
					
				

			

		

		

			
				
FutureTask类中get方法阻塞的问题：
get方法的实现：
 /**
     * @throws CancellationException {@inheritDoc}
     */
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        

			
		

	



                


  
              

                


	

		

			

				
					
FutureTask源码解读——阻塞获取异步计算结果（阻塞、取消、装饰器、适配器、Callable）

				
			

			

				

					你学废了吗？
				

				

					11-15
					
					752
					
				

			

		

		

			
				
FutureTask作为Runnable的子类，它就像是一个装饰器在Runnable异步执行的功能上，又增加了可以获取异步执行状态以及结果的功能：
其内部维护了一个`Callable`类型的成员变量，任务代码会包装成callable，FutureTask直接调用Callable.call()执行任务代码并返回结果。
还维护了一个链表实现的栈，外部获取结果的线程在任务没有执行完前都会被压入栈并阻塞（awaitDone），任务完成唤醒所有阻塞线程（finishCompletion）。

			
		

	





	

		

			

				
					
future.get方法阻塞问题的解决，实现按照任务完成的先后顺序获取任务的结果

					
热门推荐

				
			

			

				

					fourierr的博客
				

				

					05-14
					
					6万+
					
				

			

		

		

			
				
1、Future

Future模式是多线程设计常用的一种设计模式。Future模式可以理解成：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。
Future提供了三种功能：
判断任务是否完成
能够中断任务
能够获取任务执行的结果
向线程池中提交任务的submit方法不是阻塞方法，而Future...

			
		

	



		

			
		



	

		

			

				
					
重回基础----FutureTask解析（为何get方法获取会阻塞）

				
			

			

				

					CUITCUIT1的博客
				

				

					07-27
					
					1194
					
				

			

		

		

			
				
当我们在线程池中执行一个 Callable 方法时，其实是将 Callable 任务封装成一个 RunnableFuture 对象去执行，同时将这个 RunnableFuture 对象返回，这样我们就拿到了 FutureTask 的引用，可以随时获取到任务执行的状态，并且可以在任务执行完成后通过该对象获取执行结果。我们主要看下 awaitDone 方法的执行逻辑。由此可以知道，我们将一个 FutureTask 任务 submit 到线程池中执行的时候，如果发生了异常，是会在调用 get 方法的时候抛出的。

			
		

	





	

		

			

				
					
线程池执行FutureTask，得到返回结果

				
			

			

				

					Staba的博客
				

				

					04-11
					
					1246
					
				

			

		

		

			
				
一种可取消的异步计算。这个类提供了Future的基本实现，提供了启动和取消计算、查询计算是否完成以及检索计算结果的方法。只有在计算完成后才能检索结果；如果计算尚未完成，则get方法将被阻塞。一旦计算完成，就无法重新启动或取消计算（除非使用runAndReset调用计算）。FutureTask可以用于包装Callable或Runnable对象。因为FutureTask实现了Runnable，所以FutureTasks可以提交给Executor执行。

			
		

	





	

		

			

				
					
CompletableFuture 异步调用，获取返回值

				
			

			

				

					liman1002的专栏
				

				

					11-02
					
					1381
					
				

			

		

		

			
				
CompletableFuture<User> f = CompletableFuture.supplyAsync(//异步执行方法。//执行完成，设置返回结果 设置 coede 和 list。//需要执行的任务列表。//        ---------------获取返回值-----------------//因为allOf没有返回值，所以需要通过thenApply回调函数获取结果。//执行耗时较长的业务代码，这里模拟一下。// 阻塞，等待所有任务执行完成。//模拟查询用户列表。

			
		

	





	

		

			

				
					
Java 通过线程池运行Runnable Callable FutureTask，通过Future获取返回值

				
			

			

				

					linewon
				

				

					02-13
					
					1945
					
				

			

		

		

			
				
Callable是可以获取返回值的Runnable，不过Callable只能通过线程池，来直接的提交任务。

如果通过Runnable来执行任务，则只能通过FutureTask来获取返回值。



线程池ExecutoerService的execute()方法，只接收Runnable入参。要想获取任务返回值，只能通过FutureTask。

submit()方法，可以接收Runnable和Callable入参。获取返回值，既可以通过Future+Callable，也可以通过FutureTask+Runnab

			
		

	





	

		

			

				
					
Callable 和 FutureTask 带返回值线程使用和源码分析

				
			

			

				

					悟世君子的博客
				

				

					09-13
					
					467
					
				

			

		

		

			
				
Callable 和 FutureTask 可以创建带返回值的线程，那它是怎么实现的呢？笔者下面分析，先看看它是怎么使用的。

			
		

	





	

		

			

				
					
java多线程：callable和futureTask获取异步任务的返回值（实现并行计算）

				
			

			

				

					qq_41257358的博客
				

				

					01-04
					
					6939
					
				

			

		

		

			
				
场景：  我们要计算1+…+10和20+…+30相加的结果，当然可以用a=1+…+10，b=20+…+30，之后resutl=a+b。 但实际上第一个任务A和第二个任务B互不影响， 我们可以使用多线程的方法，将任务A和任务B并行执行，最后将两个任务的执行结果相加。那这样怎么用java实现呢？
引言： 在之前的 java多线程入门 中介绍了java创建多线程的方法，本质上就一种：通过Thread thread = new Thread(Runnable)创建新线程对象，实现的Runnable的run方法则为们

			
		

	





	

		

			

				
					
异步加载数据更新主线程

				
			

			

				

					08-29
				

			

		

		

			
				
Xamarin.Android开发——异步加载数据更新主线程 //异步加载数据开始 doInBackground (); //异步加载数据开始end protected async void doInBackground () {

			
		

	





	

		

			

				
					
JQuery异步获取返回值中文乱码的解决方法

				
			

			

				

					12-03
				

			

		

		

			
				
用jqgrid异步获取列表值，遇到个问题，服务器端从数据库取到的数据没有出现中文乱码问题（日志打出来是没有乱码的），但是异步传到客户的时候却出现了乱码。 服务器端已经编码过了（UTF-8编码）。开始一直怀疑是...

			
		

	





	

		

			

				
					
Java多线程（十七）：Callable、Future和FutureTask

				
			

			

				

					changhenshui1990的博客
				

				

					08-18
					
					309
					
				

			

		

		

			
				
一、Callable 与 Runnable先说一下java.lang.Runnable吧，它是一个接口，在它里面只声明了一个run()方法：public interface Runnable {
    public abstract void run();
}由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。Callable位于java.util.concurrent...

			
		

	





	

		

			

				
					
java并发编程之Future.get() 一直阻塞

				
			

			

				

					qingfeng2556的博客
				

				

					11-15
					
					296
					
				

			

		

		

			
				
担心调用量太多，允许丢弃部分结果，并行允许，定义线程池。自定义RejectedExecutionHandler，取消执行( ((FutureTask) r).cancel(true))，这样应该是最合适的。web调用时Executor.submit(),如果设置AbortPolicy时没有返回结果，只会抛出异常。转载自：https://blog.csdn.net/doctor_who2004/article/details/115647638。

			
		

	





	

		

			

				
					
Java中Future接口详解

				
			

			

				

					quanzhan_King的博客
				

				

					04-18
					
					252
					
				

			

		

		

			
				
在系统中，异步执行任务，是很常见的功能逻辑，但是在不同的场景中，又存在很多细节差异；有的任务只强调「执行过程」，并不需要追溯任务自身的「执行结果」，这里并不是指对系统和业务产生的效果，比如定时任务、消息队列等场景；但是有些任务即强调「执行过程」，又需要追溯任务自身的「执行结果」，在流程中依赖某个异步结果，判断流程是否中断，比如「并行」处理；】整个流程按照逻辑逐步推进，如果出现异常会导致流程中断；

			
		

	





	

		

			

				
					
多线程九 线程池之Future接口

				
			

			

				

					iqqcode
				

				

					08-15
					
					467
					
				

			

		

		

			
				
线程池之Future接口1. Future 和 FutureTask
1. Future 和 FutureTask
Future接口中的get()会阻塞当前线程直到取得Callable的返回值
FutureTask : 可以保证在多线程场景下，任务只会被一个线程执行，其他线程不再执行此任务；在多线程并发下可以保证任务(传入的Callable或Runnable)只执行一次

...

			
		

	





	

		

			

				
					
Java并发课程之FutureTask

				
			

			

				

					zdl_csdn的博客
				

				

					11-22
					
					200
					
				

			

		

		

			
				
Java并发课程之FutureTask
简介：  在Java中一般通过继承Thread类或者实现Runnable接口这两种方式来创建多线程，但是这两种方式都有个缺陷，就是不能在执行完成后获取执行的结果，因此Java 1.5之后提供了Callable和Future接口，通过它们就可以在任务执行完毕之后得到任务的执行结果。FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部

			
		

	





	

		

			

				
					
10张图教你同步与异步（转载）

				
			

			

				

					流楚丶格念的博客
				

				

					07-16
					
					1250
					
				

			

		

		

			
				
在这篇文章中我们从各种场景分析了同步与异步这两个概念，但是不管在什么场景下，同步往往意味着双方要相互等待、相互依赖，而异步意味着双方相互独立、各行其是。希望本篇能对大家理解这两个重要的概念有所帮助。...

			
		

	





	

		

			

				
					
jdk8新特性----Lambda表达式

					
最新发布

				
			

			

				

					w_t_y_y的博客
				

				

					05-11
					
					192
					
				

			

		

		

			
				
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。

			
		

	





	

		

			

				
					
java中既要处理异步方法的返回值,又不影响主线程运行的流程

				
			

			

				

					09-23
				

			

		

		

			
				
如果需要获取异步方法的返回值，可以使用Future对象的get方法，该方法会阻塞主线程直到异步方法执行完成并返回结果，例如： ``` String result = future.get(); ```  需要注意的是，get方法也可以设置超时时间，当...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值