【多線程】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<String> {

    @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<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        System.out.println("task return : " + futureTask.get());
    }

}

分析：

1. 方法一雖然可以實現最終打印出value值，當需要等待的方法越多，需要寫的邏輯越多，且不易控制，可謂是垃圾代碼
2. 方法二比方法一優雅許多，更加容易控制，且實現起來更加簡單，缺點是粒度不夠細
3. 方法三控制粒度更優益且更方便管理，另外可以使用線程池的方式實現