JUC并发编程第二篇，对Future的改进，CompletableFuture核心使用

一、Future和Callable接口

• Future接口定义了操作异步任务执行的一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务是否执行完毕等。
• Callable接口中定义了需要有返回的任务需要实现的方法。

二、FutureTask 的使用和存在的问题

• FutureTask使用例子

public class FutureTaskDemo
{
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException
    {
        FutureTask<Integer> futureTask = new FutureTask<>(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            return 1024;
        });

        new Thread(futureTask,"t1").start();

        System.out.println(futureTask.get());
        //只要出现get方法，不管是否计算完成都阻塞等待结果出来再运行
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 存在问题，调用get()方法会出现阻塞，不管是否计算完成都阻塞等待结果出来再运行

注意一：get()方法放在最后使用

注意二：futureTask.get(2L,TimeUnit.SECONDS)，设置超时时间

注意三：工作中不要阻塞，使用CAS，轮询代替阻塞

//轮询代替阻塞
while(true)
{
    if(futureTask.isDone())
    {
        System.out.println("----result: "+futureTask.get());
        break;
    }else{
        System.out.println("计算中......");
    }
}
1
2
3
4
5
6
7
8
9
10
11

• 轮询比阻塞好一点，但是也不推荐使用，因为轮询不一定能及时得到结果，还会白白消耗CPU资源。

我希望它任务完成时主动通知我！

多个异步任务如何合作？

三、CompletableFuture：改进解决上边Future存在问题

• CompletionStage：代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段
• CompletableFuture：实现了 Future 接口和 CompletionStage 接口，提供了非常强大的Future扩展功能，函数式编程能力，回调处理等，它可能代表一个明确完成的 Future ，也可能代表一个完成阶段，计算完成后触发某些动作。

public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {}
//CompletableFuture实现了Future老的功能，也进行了扩展CompletionStage
1
2

四、创建异步操作，CompletableFuture的四个核心静态方法

public class CompletableFutureDemo {
	public static void main(String[] args) throws ExecutionException, InterruptedException {

		/**
		 * 无返回值
		 * ForkJoinPool.commonPool-worker-3	-----come in
		 * -----task is over
		 * null
		 */
		CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
			System.out.println(Thread.currentThread().getName()+"\t"+"-----come in");
			//暂停几秒钟线程
			try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
			System.out.println("-----task is over");
		});
		System.out.println(future.get());

		/**
		 * 有返回值
		 * ForkJoinPool.commonPool-worker-3	-----come in
		 * 57
		 */
		CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
			System.out.println(Thread.currentThread().getName() + "\t" + "-----come in");
			//暂停几秒钟线程
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			return ThreadLocalRandom.current().nextInt(100);
		});

		System.out.println(completableFuture.get());

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

上边两个方法没有指定Executor的方法，直接使用默认的ForkJoinPool.commonPool() 作为它的线程池执行异步代码。

如果指定线程池，则使用我们自定义的或者特别指定的线程池执行异步代码

• CompletableFuture减少阻塞和轮询的使用

public class CompletableFutureDemo {
    public static void main(String[] args) {
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "-----come in");
            int result = ThreadLocalRandom.current().nextInt(10);
            
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("-----计算结束耗时1秒钟，result： "+result);
            if(result > 6)
            {
                int age = 10/0;
            }
            return result;
            
        }).whenComplete((v,e) ->{
            if(e == null)
            {
                System.out.println("-----result: "+v);
            }
            
        }).exceptionally(e -> {
            System.out.println("-----exception: "+e.getCause()+"\t"+e.getMessage());
            return -44;
        });

        //主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:暂停3秒钟线程
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

五、总结CompletableFuture使用及优点

• 异步任务结束时，会自动回调某个对象的方法；

• 异步任务出错时，会自动回调某个对象的方法；

• 主线程设置好回调后，不再关心异步任务的执行，异步任务之间可以顺序执行。