正文

Java线程取回结果：掌握高效获取线程执行结果的5种方法

/0 浏览量
0320

在Java中，线程是并发编程的基础。当线程执行完毕后，我们通常需要获取其执行结果。以下将详细介绍五种高效获取线程执行结果的方法。

方法一：使用Future和Callable

Callable接口与Runnable接口类似，但是它可以返回一个结果。Future接口表示异步计算的结果。以下是一个使用Callable和Future的示例：

import java.util.concurrent.*;

public class FutureExample implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 模拟耗时操作
        Thread.sleep(1000);
        return "Hello, World!";
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new FutureExample());
        String result = future.get(); // 等待结果
        System.out.println(result);
        executor.shutdown();
    }
}

方法二：使用FutureTask

FutureTask是Future接口的实现类，可以直接用于获取线程的执行结果。以下是一个使用FutureTask的示例：

import java.util.concurrent.*;

public class FutureTaskExample implements Runnable {
    private Future<String> future;

    @Override
    public void run() {
        try {
            // 模拟耗时操作
            Thread.sleep(1000);
            future = new AsyncResult("Hello, World!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public Future<String> getFuture() {
        return future;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<String> futureTask = new FutureTask<>(new FutureTaskExample());
        new Thread(futureTask).start();
        String result = futureTask.get(); // 等待结果
        System.out.println(result);
    }

    private static class AsyncResult implements Future<String> {
        private String result;

        public AsyncResult(String result) {
            this.result = result;
        }

        @Override
        public boolean cancel(boolean mayInterruptIfRunning) {
            return false;
        }

        @Override
        public boolean isCancelled() {
            return false;
        }

        @Override
        public boolean isDone() {
            return true;
        }

        @Override
        public String get() throws InterruptedException, ExecutionException {
            return result;
        }

        @Override
        public String get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
            return result;
        }
    }
}

方法三：使用join方法

join方法是Thread类提供的一个方法，它可以等待当前线程执行完毕。以下是一个使用join方法的示例：

public class JoinExample implements Runnable {
    @Override
    public void run() {
        // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread finished");
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new JoinExample());
        thread.start();
        thread.join(); // 等待线程执行完毕
        System.out.println("Main thread finished");
    }
}

方法四：使用CountDownLatch

CountDownLatch是一个同步辅助类，允许一个或多个线程等待一组事件发生。以下是一个使用CountDownLatch的示例：

import java.util.concurrent.*;

public class CountDownLatchExample implements Runnable {
    private CountDownLatch latch;

    public CountDownLatchExample(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread finished");
        latch.countDown(); // 事件发生，计数减1
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        Thread thread = new Thread(new CountDownLatchExample(latch));
        thread.start();
        latch.await(); // 等待事件发生
        System.out.println("Main thread finished");
    }
}

方法五：使用CyclicBarrier

CyclicBarrier是一个同步辅助类，允许一组线程等待彼此到达某个点。以下是一个使用CyclicBarrier的示例：

import java.util.concurrent.*;

public class CyclicBarrierExample implements Runnable {
    private CyclicBarrier barrier;

    public CyclicBarrierExample(CyclicBarrier barrier) {
        this.barrier = barrier;
    }

    @Override
    public void run() {
        // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread finished");
        try {
            barrier.await(); // 等待其他线程到达
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier barrier = new CyclicBarrier(2);
        Thread thread = new Thread(new CyclicBarrierExample(barrier));
        thread.start();
        thread.join(); // 等待线程执行完毕
        System.out.println("Main thread finished");
    }
}

以上五种方法都是高效获取线程执行结果的方法。在实际应用中，可以根据具体需求选择合适的方法。

-- 展开阅读全文 --