【多线程系列】future模式

一 序

  传统的thread里面，在执行完任务之后无法获取执行结果。通过共享变量或者使用线程通信获取结果，比较麻烦。

就是Runnable接口，线程的真正业务在run里面。

jdk1.5 开始提供Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。

二 future

    Callable 和Future位于 java.util.concurrent 包下。

  Callable 是个接口，只有一个方法call().通常配合ExecutorService使用。

  Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。参见api.归纳如下:

1）判断任务是否完成；2）能够中断任务；3）能够获取任务执行结果。

demo:

package com.daojia.future;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
/**
 * 
 * @author daojia
 *
 */
public class FutureTest {
	

	public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
		// TODO Auto-generated method stub

		useFuture();
		
	}

	 private static void useFuture() throws InterruptedException, ExecutionException, TimeoutException {  
	
	        ExecutorService exector = Executors.newFixedThreadPool(3);  
	        Future<Integer> futureA = (Future<Integer>) exector.submit(new Task("A1"));  
	        Future<Integer> futureB = (Future<Integer>) exector.submit(new Task("B1"));
	        System.out.println("a,b请求完成");
	           
	        int a=  futureA.get(1, TimeUnit.SECONDS);         
	         int b = futureB.get(1, TimeUnit.SECONDS); 	            
	     
	        exector.shutdown();  
	        System.out.println("所有任务执行完毕,res="+(a+b));
	    }  
	
}

class Task implements Callable<Integer>{
	 
	 private String name;
	 public Task(String name){
		 this.name = name;			 
	 }
	 
	    @Override
	    public Integer call() throws Exception {
	        System.out.println(System.currentTimeMillis()+" "+name+"run");
	        Random random = new Random();  
	        int num =  random.nextInt(100);
	        Thread.sleep(num);
	        System.out.println(System.currentTimeMillis()+" "+name+"runover,res="+num);
	        return num;
	    }
	}

模拟一个耗时的task,主线程负责汇总结果。，结果如下

a,b请求完成
1508849841494 A1run
1508849841495 B1run
1508849841503 B1runover,res=8
1508849841582 A1runover,res=87
所有任务执行完毕,res=95

三 JDK8 CompletableFuture

  jdk8CompletableFuture还提供了新的功能，可以对多个异步处理程序进行编排

demo:

public class FutureTest {
	

	public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
		// TODO Auto-generated method stub

		useCompletableFuture();
		
	}
 private static void useCompletableFuture() throws InterruptedException, ExecutionException {  
	        System.out.println("CompletableFuture");  
	        CompletableFuture<Void> futureA = CompletableFuture.runAsync(() -> Task("A2"));  
	        CompletableFuture<Void> futureB = CompletableFuture.runAsync(() -> Task("B2"));  
	        futureA.runAfterEither(futureB, () ->Task("C2")).get();  
	    }

	private static Object Task(String name) {
		 System.out.println(name + " starts at " + LocalTime.now());  
	        try {  
	        	Random random = new Random(); 
	            TimeUnit.SECONDS.sleep(random.nextInt(10));  
	        } catch (InterruptedException e) {  
	        }  
	        System.out.println(name + " ends at " + LocalTime.now());  
		return null;
	}  
	 
	
}

运行：

CompletableFuture
A2 starts at 21:19:43.562
B2 starts at 21:19:43.562
A2 ends at 21:19:45.563
C2 starts at 21:19:45.563
B2 ends at 21:19:46.563
C2 ends at 21:19:54.563

可见，在A或者B先处理完，C就再启动。

补充一份jdk8里面相关的类图

 
这块需要深入的学习。API很多不同的方法支持灵活的编排。