Callable与Future

最新推荐文章于 2025-05-20 16:00:00 发布

原创最新推荐文章于 2025-05-20 16:00:00 发布 · 443 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线程

Java基础专栏收录该内容

46 篇文章

订阅专栏

本文介绍了Java中的Callable接口和Future接口的使用方式及区别。Callable接口类似于Runnable，但可以通过call方法返回结果并抛出异常。Future则提供了一种异步获取Callable任务结果的方式，包括检查任务状态、取消任务和获取结果等。

Callable和Future是java的后续版本加入的内容，Callable接口和Runnable接口类似，实现Callable接口的类和实现Runnable接口的类都可以被其他线程执行的任务，它们两的不同在于：
1、Callable内定义的方法为call()，而Runnable接口定义的方法为run()
2、Callable的Call()方法有返回值，Runnable的run()方法没有返回值
3、Callable的Call()方法抛异常，Runnable的run()方法没有抛异常

Future表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。Future的cancel方法可以取消任务的执行，它有一布尔参数，参数为 true 表示立即中断任务的执行，参数为 false 表示允许正在运行的任务运行完成。Future的 get 方法等待计算完成，获取计算结果。

package Thread02;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * Future取得的结果类型和Callable返回的结果类型必须一致，这是通过泛型实现的
 * Callable要采用ExecutorService的submit方法提交，返回的Future对象可以取消任务
 * CompletionService用于提交一组Callable任务，其take方法返回已完成的一个Callable任务对应的Future对象
 */
public class CallableAndFuture {
    public static void main(String[] args) {

        ExecutorService threadPool = Executors.newSingleThreadExecutor();//创建一个线程池
        Future<String> future = threadPool.submit(new Callable<String>() {// 向线程池中提交一个任务，Callable可以返回结果，结果由Future去拿

                    @Override
                    public String call() throws Exception {
                        // TODO Auto-generated method stub
                        Thread.sleep(2000);
                        return "hello";
                    }
                });
        System.out.println("等待结果...");
        try {
            System.out.println("拿到结果：" + future.get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }




        ExecutorService threadPool2 = Executors.newFixedThreadPool(10);
        CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(
                threadPool2);
        for (int i = 1; i <= 10; i++) {
            final int temp = i;
            completionService.submit(new Callable<Integer>() {//向线程池中提交10个任务
                @Override
                public Integer call() throws Exception {
                    // TODO Auto-generated method stub
                    Thread.sleep(new Random().nextInt(5000));
                    return temp;
                }
            });
        }
        for(int i=1;i<=10;i++){
            try {
                System.out.println(completionService.take().get());//拿到最先运行完的结果，
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }   
    }
}