当前位置：首页 > Java

java线程如何返回值

2026-03-17 18:06:22Java

线程返回值的方法

在Java中，线程本身并不直接支持返回值，但可以通过以下几种方式实现线程返回值的需求。

实现Callable接口

使用Callable接口配合Future或FutureTask可以获取线程的返回值。Callable的call()方法可以返回结果，而Runnable的run()方法没有返回值。

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

public class CallableExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = () -> {
            Thread.sleep(1000);
            return 42;
        };

        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();

        Integer result = futureTask.get();
        System.out.println("Result: " + result);
    }
}

使用CompletableFuture

CompletableFuture是Java 8引入的异步编程工具，可以更方便地处理线程返回值。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        });

        Integer result = future.get();
        System.out.println("Result: " + result);
    }
}

通过共享变量传递结果

定义一个共享变量，线程执行完成后将结果写入该变量，主线程通过轮询或等待的方式获取结果。

public class SharedVariableExample {
    private static volatile Integer result = null;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(1000);
                result = 42;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread.start();
        thread.join();

        System.out.println("Result: " + result);
    }
}

使用线程池和Future

通过线程池提交Callable任务，并通过Future获取返回值。

java线程如何返回值

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

public class ThreadPoolExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(1000);
            return 42;
        });

        Integer result = future.get();
        System.out.println("Result: " + result);

        executor.shutdown();
    }
}