如何处理线程的返回值

1、主线程等待

public class MyThread implements Runnable {

    private String value;

    @Override
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        value = "I love Java!";
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t = new Thread(myThread);
        t.start();
        System.out.println("value:" + myThread.value);
    }
}

value:null

public class MyThread implements Runnable {

    private String value;

    @Override
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        value = "I love Java!";
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        Thread t = new Thread(myThread);
        t.start();
        while (myThread.value == null) {
            Thread.sleep(100);
        }
        System.out.println("value:" + myThread.value);
    }
}

value:I love Java!

2、使用Thread类的join方法阻塞当前进程以等待自线程处理完毕

public class MyThread implements Runnable {

    private String value;

    @Override
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        value = "I love Java!";
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        Thread t = new Thread(myThread);
        t.start();
        t.join();
        System.out.println("value:" + myThread.value);
    }
}

value:I love Java!

3、通过Callable接口实现，再通过FuturerTask获取返回值

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        String value = "666";
        Thread.sleep(2000);
        return value;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        Thread t = new Thread(futureTask);
        t.start();
        if (!futureTask.isDone()) {
            System.out.println("futureTask还未结束，请等待！");
        }
        System.out.println(futureTask.get());
    }
}

futureTask还未结束，请等待！
666

4、通过Callable接口实现，再通过线程池获取返回值

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        String value = "666";
        Thread.sleep(2000);
        return value;
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        MyCallable myCallable = new MyCallable();
        Future<String> future = executorService.submit(myCallable);
        if (!future.isDone()) {
            System.out.println("future还未结束，请等待！");
        }
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

future还未结束，请等待！
666