java高并发系列 - 第31天：获取线程执行结果，这6种方法你都知道？

这是java高并发系列第31篇。

环境：jdk1.8。

java高并发系列已经学了不少东西了，本篇文章，我们用前面学的知识来实现一个需求：

在一个线程中需要获取其他线程的执行结果，能想到几种方式？各有什么优缺点？

结合这个需求，我们使用6种方式，来对之前学过的知识点做一个回顾，加深记忆。

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

代码：

package com.itsoku.chat31;

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

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
public class Demo1 {
    //用于封装结果
    static class Result {
        T result;

        public T getResult() {
            return result;
        }

        public void setResult(T result) {
            this.result = result;
        }
    }

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

        //获取thread线程的执行结果
        Integer rs = result.getResult();
        System.out.println(System.currentTimeMillis());
        System.out.println(System.currentTimeMillis() + ":" + rs);
    }
}

输出：

1566733162636
1566733165692
1566733165692:10

代码中通过join方式阻塞了当前主线程，当thread线程执行完毕之后，join方法才会继续执行。

join的方式，只能阻塞一个线程，如果其他线程中也需要获取thread线程的执行结果，join方法无能为力了。

关于join()方法和线程更详细的使用，可以参考：线程的基本操作

方式2：CountDownLatch实现

代码：

package com.itsoku.chat31;

import java.util.concurrent.*;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
public class Demo2 {
    //用于封装结果
    static class Result {
        T result;

        public T getResult() {
            return result;
        }

        public void setResult(T result) {
            this.result = result;
        }
    }

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

        //获取thread线程的执行结果
        Integer rs = result.getResult();
        System.out.println(System.currentTimeMillis());
        System.out.println(System.currentTimeMillis() + ":" + rs);
    }
}

输出：

1566733720406
1566733723453
1566733723453:10

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

方式3：ExecutorService.submit方法实现

代码：

package com.itsoku.chat31;

import java.util.concurrent.*;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
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. JAVA线程池，这一篇就够了
2. JUC中的Executor框架详解1
3. JUC中的Executor框架详解2

方式4：FutureTask方式1

代码：

package com.itsoku.chat31;

import java.util.concurrent.*;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
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;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
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;

/**
 * 跟着阿里p7学并发，微信公众号：javacode2018
 */
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方法才会返回。

关于CompletableFuture更详细的使用见：JUC中工具类CompletableFuture，必备技能

java高并发系列目录

1. 第1天:必须知道的几个概念
2. 第2天:并发级别
3. 第3天:有关并行的两个重要定律
4. 第4天:JMM相关的一些概念
5. 第5天:深入理解进程和线程
6. 第6天:线程的基本操作
7. 第7天:volatile与Java内存模型
8. 第8天:线程组
9. 第9天：用户线程和守护线程
10. 第10天:线程安全和synchronized关键字
11. 第11天:线程中断的几种方式
12. 第12天JUC:ReentrantLock重入锁
13. 第13天:JUC中的Condition对象
14. 第14天:JUC中的LockSupport工具类，必备技能
15. 第15天：JUC中的Semaphore（信号量）
16. 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技能
17. 第17天：JUC中的循环栅栏CyclicBarrier的6种使用场景
18. 第18天：JAVA线程池，这一篇就够了
19. 第19天：JUC中的Executor框架详解1
20. 第20天：JUC中的Executor框架详解2
21. 第21天：java中的CAS，你需要知道的东西
22. 第22天：JUC底层工具类Unsafe，高手必须要了解
23. 第23天：JUC中原子类，一篇就够了
24. 第24天：ThreadLocal、InheritableThreadLocal（通俗易懂）
25. 第25天：掌握JUC中的阻塞队列
26. 第26篇：学会使用JUC中常见的集合，常看看！
27. 第27天：实战篇，接口性能提升几倍原来这么简单
28. 第28天：实战篇，微服务日志的伤痛，一并帮你解决掉
29. 第29天：高并发中常见的限流方式
30. 第30天：JUC中工具类CompletableFuture，必备技能

阿里p7一起学并发，公众号：路人甲java，每天获取最新文章！