CompletableFuture（一）

       CompletableFuture是java8中添加的一个类了，这个类主要的作用就是提供了新的方式来完成异步处理,包括合成和组合事件的非阻塞方式。

简单示例：
对于Future可以这样提交任务：

ExecutorService executor = Executors.newFixedThreadPool(5);

Future<String> result = executor.submit(() -> {
    TimeUnit.SECONDS.sleep(3);
    return "hello";
});
System.out.println(result.get());

使用CompletableFuture：

CompletableFuture<String> resultCompletableFuture = CompletableFuture.supplyAsync(new Supplier<String>() {
    @Override
    public String get() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return "hello";
    }
}, executor);
System.out.println(resultCompletableFuture.get());

这里，CompletableFuture和Future的get()调用都会阻塞，但是可以CompletableFuture注册类似一个回调函数去处理结果：

CompletableFuture<String> resultCompletableFuture = CompletableFuture.supplyAsync(new Supplier<String>() {
    @Override
    public String get() {
	try {
	    TimeUnit.SECONDS.sleep(1);
	    System.out.println(Thread.currentThread().getName());
	} catch (InterruptedException e) {
	   e.printStackTrace();
	}
	return "hello";
    }
}, executor);
System.out.println(resultCompletableFuture.thenAccept(new Consumer<String>(){
    @Override
    public void accept(String t) {
	System.out.println(t);
	System.out.println(Thread.currentThread().getName());
    }
}));
System.out.println(123);

运行结果：

java.util.concurrent.CompletableFuture@1b28cdfa[Not completed]
123
pool-1-thread-2
hello
pool-1-thread-2

可以看出来，在CompletableFuture注册的回调函数的执行与其提交的任务的执行是同一个线程完成的。如果不想同一个线程来完成回调函数，可以这样：

CompletableFuture<String> resultCompletableFuture = CompletableFuture.supplyAsync(new Supplier<String>() {
    @Override
    public String get() {
	try {
	    TimeUnit.SECONDS.sleep(1);
	    System.out.println(Thread.currentThread().getName());
	} catch (InterruptedException e) {
	    // TODO Auto-generated catch block
	    e.printStackTrace();
	}
	return "hello";
    }
}, executor);
resultCompletableFuture.thenAcceptAsync(new Consumer<String>() {
    @Override
    public void accept(String t) {
	System.out.println(t);
	System.out.println(Thread.currentThread().getName());
    }
}, executor);
System.out.println(123);

这里第二个参数executor也可以使用其它的线程池，当然如果不指定第二个参数，即

resultCompletableFuture.thenAcceptAsync(new Consumer<String>() {
            @Override
            public void accept(String t) {
                System.out.println(t);
                System.out.println(Thread.currentThread().getName());
            }
        });

这时会使用ForkJoinPool.commonPool这个线程池。

可以对通过completeExceptionally 函数对CompletableFuture发出异常通知：

CompletableFuture<String> resultCompletableFuture = CompletableFuture.supplyAsync(new Supplier<String>() {
    @Override
    public String get() {
	try {
	    TimeUnit.SECONDS.sleep(3);
	    System.out.println("run--" + Thread.currentThread().getName());
	} catch (InterruptedException e) {
	    e.printStackTrace();
	}
	return "hello";
    }
}, executor);
resultCompletableFuture.thenAccept(new Consumer<String>() {
    @Override
    public void accept(String t) {
	System.out.println("accept--" + t);
	System.out.println(Thread.currentThread().getName());
    }
});
resultCompletableFuture.completeExceptionally(new Exception("error"));
System.out.println("over");

运行结果：

over
run--pool-1-thread-1

可以发现thenAccept注册的回调函数不再执行，但是任务还是会执行完。
可以显式声明来处理异常：

CompletableFuture<String> resultCompletableFuture = CompletableFuture.supplyAsync(new Supplier<String>() {
    @Override
    public String get() {
	try {
	    TimeUnit.SECONDS.sleep(3);
	    System.out.println("run--" + Thread.currentThread().getName());
	} catch (InterruptedException e) {
	    e.printStackTrace();
	}
	return "hello";
    }
}, executor);
resultCompletableFuture.thenAccept(new Consumer<String>() {
    @Override
    public void accept(String t) {
	System.out.println("accept--" + t);
	System.out.println(Thread.currentThread().getName());
    }
}).exceptionally(new Function<Throwable, Void>(){
    @Override
    public Void apply(Throwable t) {
	System.out.println(t.getMessage());
	return null;
    }
});
resultCompletableFuture.completeExceptionally(new Exception("error"));
System.out.println("over");

运行结果：

java.lang.Exception: error
over
run--pool-1-thread-1

但是，如果exceptionally的声明提前了呢？

CompletableFuture<String> resultCompletableFuture = CompletableFuture.supplyAsync(new Supplier<String>() {
    @Override
    public String get() {
	try {
	    TimeUnit.SECONDS.sleep(3);
	    System.out.println("run--" + Thread.currentThread().getName());
	} catch (InterruptedException e) {
	    e.printStackTrace();
	}
	return "hello";
    }
}, executor);
resultCompletableFuture.exceptionally(new Function<Throwable, String>() {
    @Override
    public String apply(Throwable t) {
	System.out.println(t.getMessage());
	return t.getMessage();
    }
}).thenAccept(new Consumer<String>() {
    @Override
    public void accept(String t) {
	System.out.println("accept--" + t);
	System.out.println("accept--" + Thread.currentThread().getName());
    }
});
resultCompletableFuture.completeExceptionally(new Exception("error"));
System.out.println("over");

注意到，两次exceptionally的参数Function <T, R>的类型值是不一样的，运行结果：

error
accept--error
accept--main
over
run--pool-1-thread-1

可以看出，在thenAccept前声明的exceptionally会有一个返回值传递给thenAccept。