Java多线程相关的常用接口

Runnable 是一个接口，里面只声明了一个方法run();返回值为void所以无法拿到执行完的结果。只能通过共享变量或者线程通信来搞定。
Future就是对具体的Runable或者Callable任务的执行结果进行取消，查询是否完成，获取结果。
FutureTask实现了RunnableFuture接口,RunableFuture接口继承了Runable和Future接口，所以他既可以被线程执行，也可以作为Future得到Callable的返回值。
CompletableFutures是java8中新增加的一个类，主要用来处理异步。CompletableFuture不但可以调用get()方法获取执行结果，也可以使用回调函数来得到处理结果CompletableFuture可以通过completeExceptionally 函数来发出异常通知，同时我们也可以显示声明异常处理。CompletableFuture还有许多方法，来满足不同的需求场景，具体的方法 还需要使用到的时候在来进行具体分析。

在两个线程里并行执行任务A和任务B，只要有一个任务完成了，就执行任务C。代码如下：

1. import java.time.LocalTime;
2. import java.util.Random;
3. import java.util.concurrent.CompletableFuture;
4. import java.util.concurrent.ExecutionException;
5. import java.util.concurrent.ExecutorService;
6. import java.util.concurrent.Executors;
7. import java.util.concurrent.Future;
8. import java.util.concurrent.TimeUnit;
9. import java.util.concurrent.TimeoutException;
10. public class LearnCompleteFuture {
11. private static Random random = new Random();
12. public static void main(String[] args) throws InterruptedException, ExecutionException {
13. useFuture();
14. TimeUnit.SECONDS.sleep(10);
15. System.out.println();
16. useCompletableFuture();
17. }
18. private static void useFuture() throws InterruptedException, ExecutionException {
19. System.out.println("Future");
20. ExecutorService exector = Executors.newFixedThreadPool(3);
21. Future<Void> futureA = exector.submit(() -> work("A1"));
22. Future<Void> futureB = exector.submit(() -> work("B1"));
23. while (true) {
24. try {
25. futureA.get(1, TimeUnit.SECONDS);
26. break;
27. } catch (TimeoutException e) {
28. }
29. try {
30. futureB.get(1, TimeUnit.SECONDS);
31. break;
32. } catch (TimeoutException e) {
33. }
34. }
35. exector.submit(() -> work("C1")).get();
36. exector.shutdown();
37. }
38. private static void useCompletableFuture() throws InterruptedException, ExecutionException {
39. System.out.println("CompletableFuture");
40. CompletableFuture<Void> futureA = CompletableFuture.runAsync(() -> work("A2"));
41. CompletableFuture<Void> futureB = CompletableFuture.runAsync(() -> work("B2"));
42. futureA.runAfterEither(futureB, () -> work("C2")).get();
43. }
44. public static Void work(String name) {
45. System.out.println(name + " starts at " + LocalTime.now());
46. try {
47. TimeUnit.SECONDS.sleep(random.nextInt(10));
48. } catch (InterruptedException e) {
49. }
50. System.out.println(name + " ends at " + LocalTime.now());
51. return null;
52. }
53. }

两种方法useFuture和useCompletableFuture相比：

首先，方法2 比 方法1 的代码简单。在方法1里，既要自己照顾线程池的创建和销毁，还要负责对任务A和任务B的监控。而方法2，只需要用CompletableFuture的runAfterEither就完成了任务A、任务B和任务C之间的依赖关系的定义。

在方法2，甚至用一行代码就能完成：

1. CompletableFuture.runAsync(() -> work("A2")).runAfterEither(CompletableFuture.runAsync(() -> work("B2")), () -> work("C2")).get();

其次，方法2 比 方法1 高效。

方法1的主线程，要通过while(true)的方式不断地轮询任务A和任务B的运行状况，浪费CPU资源，而方法2的主线程只需要在最后的get()上静静地等待任务C的完成。

http://blog.csdn.net/zjysource/article/details/54409772