怎么获取Thread返回值？（FutureTask解读）

堕落的人生啊……

如何获取Thread返回值？

偶然间看到这个问题，对于标配jdk1.8的我们是不是分分钟拍出答案？
答曰：简单，Callable，完美解决，下一题……

可是，身处jdk1.4（甚至更早）的前辈们，要怎么做才能拿到线程返回值呢？或者说，禁用Callable技能，怎么获取线程返回值？
嗯，这似乎是线程间通信的问题；只有Runnable作为武器，有些麻烦，接受挑战！

首先，定义任务Task

// 任务Task
class Task implements Runnable{

    @Getter
    Object result;    //返回值

    @Override
    public void run() {
        try {
            // 模拟某耗时逻辑
            System.out.println(String.format("[%s] 执行中..",Thread.currentThread().getName()));
            TimeUnit.SECONDS.sleep(2L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 计算得到最终结果
        result = Integer.valueOf(9987);
        
        System.out.println(String.format("[%s] 执行完毕..",Thread.currentThread().getName()));
    }
}

之后，启动线程

public static void main(String[] args) {
    // 使用了内部类，采用如下方式new
    CallbackTest callbackTest = new CallbackTest();
    Task task = callbackTest.new Task();
    
    final String threadName = "T-1";
    Thread thread = new Thread(task,threadName);

    thread.start();
    
}

好，T-1线程启动了，看样子能很好的执行任务，问题是main方法中怎么获取到Task的返回值result呢？
以目前的代码运行，效果绝对是T-1线程单飞，和main线程没啥联系。

我有一项能力，总是能第一时间相当最简易的方法。

简单方式

main线程辛苦些，多跑跑腿检查下result的状态：

public static void main(String[] args) {
    CallbackTest callbackTest = new CallbackTest();
    Task task = callbackTest.new Task();
    final String threadName = "T-1";
    Thread thread = new Thread(task,threadName);
    thread.start();
    
    // main线程频繁检查T-1线程
    while (true){
        if(task.getResult()!=null){
            System.out.println(String.format("结果 task=%s",task.getResult()));
            break;
        }

        // 让cpu稍微冷静一下
        TimeUnit.MILLISECONDS.sleep(200L);
        System.out.println(String.format("[main] 勤劳检查result中（result=%s）",task.getResult()));
    }
}

运行效果，可能是这样的：

[T-1] 执行中..
[main] 勤劳检查result中（result=null）
[main] 勤劳检查result中（result=null）
[main] 勤劳检查result中（result=null）
[main] 勤劳检查result中（result=null）
[main] 勤劳检查result中（result=null）
[main] 勤劳检查result中（result=null）
[main] 勤劳检查result中（result=null）
[main] 勤劳检查result中（result=null）
[main] 勤劳检查result中（result=null）
[T-1] 执行完毕..
[main] 勤劳检查result中（result=9987）
结果 task=9987

虽然已加入了对cpu而言人性化的休眠方法（sleep），但这依然不是个很好的方案。该方案极大的操劳了main线程，需要一遍遍的检查子线程的运行情况——子线程是否将最终结果赋值。
那有没有一种方式，可以在T-1运行完之后，告诉main线程呢？
作为一个老派（技术陈旧）的程序员，我首先想到的是wait..notify组合

wait..notify组合方式

• wait部分，检查result值，如果为null则表示T-1还未执行完，安心等待

public static void main(String[] args){

        CallbackTest callbackTest = new CallbackTest();
        Task task = callbackTest.new Task();
        final String threadName = "T-1";
        Thread thread = new Thread(task,threadName);
        thread.start();

        while (true){
            //检查result状态，还没有赋值，则等待
            if(task.getResult()==null){
                System.out.println(String.format("[%s] 等待执行..",Thread.currentThread().getName()));
                synchronized (task){
                    try {
                        task.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

            if(task.getResult()!=null){
                System.out.println(String.format("结果 task=%s",task.getResult()));
                break;
            }
        }

    }

• notify部分，增加唤醒逻辑

class Task implements Runnable{

    @Getter
    Object result;
    
    @Override
    public void run() {
        try {
            System.out.println(String.format("[%s] 执行中..",Thread.currentThread().getName()));
            TimeUnit.SECONDS.sleep(2L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    
        result = Integer.valueOf(9987);
    
        //唤醒wait的对象
        synchronized (this){
            this.notify();
        }
        System.out.println(String.format("[%s] 执行完毕..",Thread.currentThread().getName()));
    }
}

改造后，执行效果如下：

[T-1] 执行中..
[main] 等待执行..
[T-1] 执行完毕..
结果 task=9987

LockSupport实现

其实也可以使用LockSupport实现，和 wait / notify 类似，直接贴出完整代码吧：

public class CallbackTest {
    class Task implements Runnable{
    
        @Getter
        Object result;
    
        // 构造函数传入调用线程（main线程）
        Thread runner;
        Task(Thread runner){
            this.runner = runner;
        }
    
        @Override
        public void run() {
            try {
                System.out.println(String.format("[%s] 执行中..",Thread.currentThread().getName()));
                TimeUnit.SECONDS.sleep(2L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            result = Integer.valueOf(9987);
    
            //唤醒main线程
            synchronized (this){
                LockSupport.unpark(runner);
            }
            System.out.println(String.format("[%s] 执行完毕..",Thread.currentThread().getName()));
        }
    }
    
    public static void main(String[] args) {
    
        CallbackTest callbackTest = new CallbackTest();
        Task task = callbackTest.new Task(Thread.currentThread());
        final String threadName = "T-1";
        Thread thread = new Thread(task,threadName);
    
        thread.start();
    
        while (true){
            if(task.getResult()==null){
                System.out.println(String.format("[%s] 等待执行..",Thread.currentThread().getName()));
                LockSupport.park(); //main线程阻塞
            }
    
            if(task.getResult()!=null){
                System.out.println(String.format("结果 task=%s",task.getResult()));
                break;
            }
        }
    
    }
}

Callable使用

至此，我们相当于可以用自己的方式获取到Thread的返回值了，此时回顾下文章开始初的解答：

偶然间看到这个问题，对于标配`jdk1.8`的我们是不是分分钟拍出答案？
答曰：简单，`Callable`，完美解决，下一题……

当时很自然的就回答了Callable，先看看它是怎么用的。

public class CallbackTest {

    class Task implements Callable