java 高并发系列已经学了不少东西了，本篇文章，我们用前面学的知识来实现一个需求：
在一个线程中需要获取其他线程的执行结果，能想到几种方式？各有什么优缺点？
结合这个需求，我们使用6 种方式，来对之前学过的知识点做一个回顾，加深记忆。

方式 1：Thread 的 join()方法实现

代码：
package com.itsoku.chat31;

import java.sql.Time;
import java.util.concurrent.*;

/
微信公众号：程序员路人，个人博客：http://www.itsoku.com
/
public class Demo1 {
//用于封装结果
static class Result<T**> {
T result;

  1.     **public** T **getResult**() {<br />            **return** result;<br />        }
  3.     **public** **void** **setResult**(T result) {<br />            **this**.result = result;<br />        }<br />    }
  5. **public** **static** **void** **main**(String[] args) **throws** ExecutionException, InterruptedException {<br />        System.out.println(System.currentTimeMillis());<br />        //用于存放子线程执行的结果<br />        Result<Integer> result = **new** Result<>();<br />        //创建一个子线程<br />        Thread thread = **new** Thread(() -> {<br />            **try** {<br />                TimeUnit.SECONDS.sleep(3);<br />                result.setResult(10);<br />            } **catch** (InterruptedException e) {<br />                e.printStackTrace();<br />            }<br />        });<br />        thread.start();<br />        //让主线程等待thread线程执行完毕之后再继续，join方法会让当前线程阻塞<br />        thread.join();
  7.     //获取thread线程的执行结果<br />        Integer rs = result.getResult();<br />        System.out.println(System.currentTimeMillis());<br />        System.out.println(System.currentTimeMillis() + ":" + rs);<br />    }<br />}

输出：
1566733162636
1566733165692
1566733165692:10

代码中通过 join 方式阻塞了当前主线程，当 thread 线程执行完毕之后，join 方法才会继续执行。
关于 join()方法和线程更详细的使用，可以参考：线程的基本操作

方式 2：CountDownLatch 实现

代码：
package com.itsoku.chat31;

import java.util.concurrent.*;

/
微信公众号：程序员路人，个人博客：http://www.itsoku.com
/
public class Demo2 {
//用于封装结果
static class Result<T**> {
T result;

  1.     **public** T **getResult**() {<br />            **return** result;<br />        }
  3.     **public** **void** **setResult**(T result) {<br />            **this**.result = result;<br />        }<br />    }
  5. **public** **static** **void** **main**(String[] args) **throws** ExecutionException, InterruptedException {<br />        System.out.println(System.currentTimeMillis());<br />        CountDownLatch countDownLatch = **new** CountDownLatch(1);<br />        //用于存放子线程执行的结果<br />        Demo1.Result<Integer> result = **new** Demo1.Result<>();<br />        //创建一个子线程<br />        Thread thread = **new** Thread(() -> {<br />            **try** {<br />                TimeUnit.SECONDS.sleep(3);<br />                result.setResult(10);<br />            } **catch** (InterruptedException e) {<br />                e.printStackTrace();<br />            }**finally** {<br />                countDownLatch.countDown();<br />            }<br />        });<br />        thread.start();<br />        //countDownLatch.await()会让当前线程阻塞，当countDownLatch中的计数器变为0的时候，await方法会返回<br />        countDownLatch.await();
  7.     //获取thread线程的执行结果<br />        Integer rs = result.getResult();<br />        System.out.println(System.currentTimeMillis());<br />        System.out.println(System.currentTimeMillis() + ":" + rs);<br />    }<br />}

输出：
1566733720406
1566733723453
1566733723453:10

上面代码也达到了预期效果，使用CountDownLatch可以让一个或者多个线程等待一批线程完成之后，自己再继续；CountDownLatch更详细的介绍见：JUC 中等待多线程完成的工具类 CountDownLatch，必备技能

方式 3：ExecutorService.submit 方法实现

代码：
package com.itsoku.chat31;

import java.util.concurrent.*;

/
微信公众号：程序员路人，个人博客：http://www.itsoku.com
/
public class Demo3 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建一个线程池
ExecutorService executorService = Executors.newCachedThreadPool();
System.out.println(System.currentTimeMillis());
Future future = executorService.submit(() -> {
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
return** 10;
});
//关闭线程池
executorService.shutdown();
System.out.println(System.currentTimeMillis());
Integer result = future.get();
System.out.println(System.currentTimeMillis() + “:” + result);
}
}

输出：
1566734119938
1566734119989
1566734122989:10

使用ExecutorService.submit方法实现的，此方法返回一个Future，future.get()会让当前线程阻塞，直到 Future 关联的任务执行完毕。
相关知识：

  1. 吃透线程池
  2. JUC 中的 Executor 框架详解 1
  3. JUC 中的 Executor 框架详解 2

    方式 4：FutureTask 方式 1

    代码：
    package com.itsoku.chat31;

import java.util.concurrent.*;

/
微信公众号：程序员路人，个人博客：http://www.itsoku.com
/
public class Demo4 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println(System.currentTimeMillis());
//创建一个FutureTask
FutureTask futureTask = new FutureTask<>(() -> {
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 10;
});
//将futureTask传递一个线程运行
new** Thread(futureTask).start();
System.out.println(System.currentTimeMillis());
//futureTask.get()会阻塞当前线程，直到futureTask执行完毕
Integer result = futureTask.get();
System.out.println(System.currentTimeMillis() + “:” + result);
}
}

输出：
1566736350314
1566736350358
1566736353360:10

代码中使用FutureTask实现的，FutureTask 实现了Runnable接口，并且内部带返回值，所以可以传递给 Thread 直接运行，futureTask.get()会阻塞当前线程，直到FutureTask构造方法传递的任务执行完毕，get 方法才会返回。关于FutureTask详细使用，请参考：JUC 中的 Executor 框架详解 1

方式 5：FutureTask 方式 2

代码：
package com.itsoku.chat31;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

/
微信公众号：程序员路人，个人博客：http://www.itsoku.com
/
public class Demo5 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println(System.currentTimeMillis());
//创建一个FutureTask
FutureTask futureTask = new FutureTask<>(() -> 10);
//将futureTask传递一个线程运行
new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(3);
} catch** (InterruptedException e) {
e.printStackTrace();
}
futureTask.run();
}).start();
System.out.println(System.currentTimeMillis());
//futureTask.get()会阻塞当前线程，直到futureTask执行完毕
Integer result = futureTask.get();
System.out.println(System.currentTimeMillis() + “:” + result);
}
}

输出：
1566736319925
1566736319970
1566736322972:10

创建了一个FutureTask对象，调用futureTask.get()会阻塞当前线程，子线程中休眠了 3 秒，然后调用futureTask.run();当 futureTask 的 run()方法执行完毕之后，futureTask.get()会从阻塞中返回。
注意：这种方式和方式 4 的不同点。
关于FutureTask详细使用，请参考：JUC 中的 Executor 框架详解 1

方式 6：CompletableFuture 方式实现

代码：
package com.itsoku.chat31;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

/
微信公众号：程序员路人，个人博客：http://www.itsoku.com
/
public class Demo6 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println(System.currentTimeMillis());
CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
return** 10;
});
System.out.println(System.currentTimeMillis());
//futureTask.get()会阻塞当前线程，直到futureTask执行完毕
Integer result = completableFuture.get();
System.out.println(System.currentTimeMillis() + “:” + result);
}
}

输出：
1566736205348
1566736205428
1566736208429:10

CompletableFuture.supplyAsync可以用来异步执行一个带返回值的任务，调用completableFuture.get()
会阻塞当前线程，直到任务执行完毕，get 方法才会返回。