Java 获取子线程返回值的最佳实践

在 Java 中，获取子线程的返回值可以通过以下几种方式实现：

使用 Callable 和 Future：可以通过创建一个实现了 Callable 接口的任务，并将其提交给一个 ExecutorService 线程池来执行。然后可以通过调用 Future 的 get() 方法来获取子线程的返回值。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<String> future = executorService.submit(new MyCallable());
        try {
            String result = future.get(); // 获取子线程的返回值
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
    }
}

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 子线程的逻辑
        // 返回子线程的结果
        return '子线程的返回值';
    }
}

使用 Thread 的 join() 方法：可以在主线程中创建子线程，并在主线程中调用子线程的 join() 方法，等待子线程执行完毕后再继续执行主线程。在子线程中可以定义一个成员变量来保存返回值，然后通过 getter 方法获取。

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {
            thread.join(); // 等待子线程执行完毕
            String result = thread.getResult(); // 获取子线程的返回值
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyThread extends Thread {
    private String result;

    @Override
    public void run() {
        // 子线程的逻辑
        // 设置子线程的返回值
        result = '子线程的返回值';
    }

    public String getResult() {
        return result;
    }
}

使用线程间共享的变量：可以在主线程和子线程之间定义一个共享的变量，在子线程中修改共享变量的值，主线程中通过读取共享变量来获取子线程的返回值。

public class Main {
    public static void main(String[] args) {
        SharedVariable sharedVariable = new SharedVariable();
        Thread thread = new Thread(new MyRunnable(sharedVariable));
        thread.start();
        try {
            thread.join(); // 等待子线程执行完毕
            String result = sharedVariable.getResult(); // 获取子线程的返回值
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyRunnable implements Runnable {
    private SharedVariable sharedVariable;

    public MyRunnable(SharedVariable sharedVariable) {
        this.sharedVariable = sharedVariable;
    }

    @Override
    public void run() {
        // 子线程的逻辑
        // 设置共享变量的值
        sharedVariable.setResult('子线程的返回值');
    }
}

class SharedVariable {
    private String result;

    public String getResult() {
        return result;
    }

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

这些方法都可以用来获取子线程的返回值，具体选择哪种方式取决于具体的需求和场景。