【多线程】3、如何实现处理线程的返回值

初始实例：

public class CycleWait implements Runnable {

    private String value;

    public static void main(String[] args) {
        CycleWait cycleWait = new CycleWait();
        Thread thread = new Thread(cycleWait);
        thread.start();
        System.out.println(cycleWait.value);
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        value = "we have data now";
    }

}

实现的方法主要有三种：

1. 主线程等待法
2. 使用Thread类的join()阻塞当前线程以等待子线程处理完毕
3. 通过Callable接口实现：通过FutureTask Or 线程池来获取

// 方法一
while (cycleWait.value == null) {
    Thread.currentThread().sleep(200);
}

 

// // 方法二
thread.join();

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

// 方法三
public class MyCallable implements Callable {

    @Override
    public String call() throws Exception {
        String value = "test";
        System.out.println("Ready to work...");
        Thread.sleep(5000);
        System.out.println("task done...");
        return value;
    }

    public static void main(String[] args) throws Exception {
        MyCallable callable = new MyCallable();
        FutureTask futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        System.out.println("task return : " + futureTask.get());
    }

}

分析：

1. 方法一虽然可以实现最终打印出value值，当需要等待的方法越多，需要写的逻辑越多，且不易控制，可谓是垃圾代码
2. 方法二比方法一优雅许多，更加容易控制，且实现起来更加简单，缺点是粒度不够细
3. 方法三控制粒度更优益且更方便管理，另外可以使用线程池的方式实现