Callable、Future和FutureTas浅析

最新推荐文章于 2022-06-04 17:36:15 发布
最新推荐文章于 2022-06-04 17:36:15 发布
阅读量204 收藏
点赞数 1
分类专栏： Java 并发编程 文章标签： Callable Future FutureTas 创建线程的几种方式 创建带有返回值的线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daidaineteasy/article/details/115680163
版权

文章目录

创建线程的方式

Java 中想要创建一个线程，比较容易的两种实现方式是继承 Thread 类或者实现 Runnable 接口。

以实现 Runnable 接口为例：

public class MyRunnableThread implements Runnable{

    @Override
    public void run() {
        System.out.println("子线程开始执行");
    }

    public static void main(String[] args) {
        // 创建线程对象并启动
        new Thread(new MyRunnableThread()).start();// 执行后输出：子线程开始执行
    }
}

上边这段代码比较简单，但存在个问题，它的 run 方法没有返回值。如果我们想要获取返回值，还需要做一些额外的操作，比如下边的代码：

public class MyRunnableThread implements Runnable{

    /**
     * 用来保存 run 方法的返回结果
     */
    private volatile String result;

    @Override
    public void run() {

        System.out.println("子线程开始执行");
        try {
            // 假设执行一些任务花费的时长
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 执行完后，将结果保存到 result 中
        result = "OK";
    }

    /**
     * 获取返回结果
     * @return
     */
    public String getResult(){
        while(true){
            if(null != result){
                // 有结果后返回
                return result;
            }
            // 让出一下 CPU 时间片，过会再来看看
            Thread.yield();
        }

    }

    public static void main(String[] args) {
        // 创建线程对象并启动
        MyRunnableThread myRunnableThread = new MyRunnableThread();
        new Thread(myRunnableThread).start();

        long start = System.currentTimeMillis();
        System.out.println("getResult 返回结果："+myRunnableThread.getResult());
        long end = System.currentTimeMillis();

        System.out.println("getResult 花费的时间：" + (end - start));
    }
}

main 方法执行后输出：

子线程开始执行
getResult 返回结果：OK
getResult 花费的时间：3008

如上边这段代码，如果想要一个返回结果，那么就需要将结果保存到变量，还要提供额外的方法读取，非常不便。

什么是 Callable 和 Future

Callable 接口类似于 Runnable 接口， Runnable 没有返回结果，并且无法抛出返回结果的异常，而 Callable 功能更强大一些，被线程执行后，可以有返回值：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

这个返回值可以被 Future 拿到，也就是说，Future 可以拿到异步执行任务的返回值。可以认为 Callable 是带有返回值的 Runnable 。
而 Future 类型的实例代表一个未来能获取结果的对象。所以说 Callable 用于产生结果，Future 用于获取结果。

通过 Callable 和 Future 来创建有返回值的线程

public class MyCallableThread implements Callable {

    @Override
    public Object call() throws Exception {
        System.out.println("子线程开始执行");
        // 假设执行一些任务花费的时长
        Thread.sleep(3000);

        return "OK";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 创建 Callable 任务
        Callable callable = new MyCallableThread();

        // 将 Callable 任务提交给线程池去执行并拿到 Future
        ExecutorService executor = Executors.newFixedThreadPool(1);
        Future<String> future = executor.submit(callable);

        long start = System.currentTimeMillis();

        // 从 Future 获取异步执行返回的结果
        System.out.println("返回结果：" + future.get());

        long end = System.currentTimeMillis();

        System.out.println("获取返回结果花费时间：" + (end-start));
        
		// 关闭线程池
        executor.shutdown();
    }

}

main 方法执行后输出：

子线程开始执行
返回结果：OK
获取返回结果花费时间：3002

上边这段代码就简单多了：

  1. 创建 Callable 类型的对象；
  2. 创建线程池；
  3. 将 Callable 类型对象提交给线程池执行，并得到 Future 对象；
  4. 获取结果。

这里在调用 Future 的 get() 方法时，如果异步任务已经完成，我们就直接获得结果。如果异步任务还没有完成，那么 get() 会阻塞，直到任务完成后才返回结果。

除了 get() 方法，Future 中还定义了其它一些方法：

  • boolean cancel(boolean mayInterruptIfRunning); 取消当前任务；
  • boolean isCancelled(); 判断任务是否被取消
  • boolean isDone(); 判断任务是否已完成
  • V get(); 获取结果（可能会等待）
  • V get(long timeout, TimeUnit unit); 获取结果，但只等待指定的时间；

什么是 FutureTask

FutureTask 是 Future 接口的实现类，也可以代表异步计算的结果。除了实现 Future 接口外，FutureTask 还实现了 Runnable 接口，因此，FutureTask 可以交给线程池去执行，也可以由调用线程直接执行。

FutureTask 有两个构造方法

public FutureTask(Callable<V> callable) {
	if (callable == null)
		throw new NullPointerException();
	this.callable = callable;
	this.state = NEW;
}

public FutureTask(Runnable runnable, V result) {
	this.callable = Executors.callable(runnable, result);
	this.state = NEW;
}

第一个构造方法传入的是一个 Callable 类型的对象，第二个构造方法传入的是一个 Runnable 类型的对象，但在内部又被 Executors 工厂类包装成了 Callable 类型对象。

通过 Callable 和 FutureTask 来创建有返回值的线程

public class MyCallableThread implements Callable {

    @Override
    public Object call() throws Exception {
        System.out.println("子线程开始执行");
        // 假设执行一些任务花费的时长
        Thread.sleep(3000);

        return "OK";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 创建 Callable 任务
        Callable callable = new MyCallableThread();

        // 创建 FutureTask 任务
        FutureTask futureTask = new FutureTask(callable);
        // 开启线程去执行 FutureTask 任务
        new Thread(futureTask).start();

        long start = System.currentTimeMillis();

        // 从 Future 获取异步执行返回的结果
        System.out.println("返回结果：" + futureTask.get());

        long end = System.currentTimeMillis();

        System.out.println("获取返回结果花费时间：" + (end-start));
    }

}

main 方法执行后输出：

子线程开始执行
返回结果：OK
获取返回结果花费时间：3002

案例示范

假如我们调一个下单接口，接口中需要查询客户信息（耗时1s）、商品信息（耗时2s）、账户信息（耗时4s）等，如果按照串行化执行，执行完后，总共耗时：7s （1+2+4）。

示例代码如下：

public class Test {

    public static void main(String[] args) throws InterruptedException {

        long start = System.currentTimeMillis();

        // 查询客户信息
        Object customer = getCustomer();
        // 查询商品信息
        Object goods = getGoods();
        // 查询账户信息
        Object account = getAccount();

        System.out.println("客户信息：" + customer);
        System.out.println("商品信息：" + goods);
        System.out.println("账户信息：" + account);

        long end = System.currentTimeMillis();

        System.out.println("花费时长：" + (end - start));

    }

    /**
     * 模拟查询客户信息
     */
    public static Object getCustomer() throws InterruptedException {
        // 假设查询需要花费1s
        Thread.sleep(1000);
        return "customerData";
    }

    /**
     * 模拟查询商品信息
     */
    public static Object getGoods() throws InterruptedException {
        // 假设查询需要花费2s
        Thread.sleep(2000);
        return "goodsData";
    }

    /**
     * 模拟查询账户信息
     */
    public static Object getAccount() throws InterruptedException {
        // 假设查询需要花费4s
        Thread.sleep(4000);
        return "accountData";
    }
}

main 方法执行后输出：

客户信息：customerData
商品信息：goodsData
账户信息：accountData
花费时长：7002

我们再来通过有返回值的多线程试下：

public class Test {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        long start = System.currentTimeMillis();

        // 创建一个定长线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 将查询操作提交给线程池执行
        Future<Object> customerFuture = executor.submit(Test::getCustomer);
        Future<Object> goodsFuture = executor.submit(Test::getGoods);
        Future<Object> accountFuture = executor.submit(Test::getAccount);

        // 获得客户信息
        Object customer = customerFuture.get();
        // 获得商品信息
        Object goods = goodsFuture.get();
        // 获得账户信息
        Object account = accountFuture.get();

        System.out.println("客户信息：" + customer);
        System.out.println("商品信息：" + goods);
        System.out.println("账户信息：" + account);

        long end = System.currentTimeMillis();

        // 关闭线程池
        executor.shutdown();

        System.out.println("花费时长：" + (end - start));

    }

    /**
     * 模拟查询客户信息
     */
    public static Object getCustomer() throws InterruptedException {
        // 假设查询需要花费1s
        Thread.sleep(1000);
        return "customerData";
    }

    /**
     * 模拟查询商品信息
     */
    public static Object getGoods() throws InterruptedException {
        // 假设查询需要花费2s
        Thread.sleep(2000);
        return "goodsData";
    }

    /**
     * 模拟查询账户信息
     */
    public static Object getAccount() throws InterruptedException {
        // 假设查询需要花费4s
        Thread.sleep(4000);
        return "accountData";
    }
}

main 方法执行后输出：

客户信息：customerData
商品信息：goodsData
账户信息：accountData
花费时长：4058

通过输出可以看出，时间只花费了 4s。这比较容易理解，因为并行的时候，花费的时间只跟耗时最长的线程有关。

晓呆同学
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java使用Callable和Future创建线程操作示例
08-25
Java使用Callable和Future创建线程操作示例主要介绍了Java使用Callable和Future创建线程操作，结合实例形式分析了java使用Callable接口和Future类创建线程的相关操作技巧与注意事项。 首先，Java 5开始，Java提供了...
Java并发编程：Callable、Future和FutureTas
CHBSRZF的博客
10-21 544
在前面的文章中我们讲述了创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。 　　如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。 　　而自从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务
Java中Future和FutureTask详解及使用
Charte的博客
11-29 1万+
文章目录一、Future 接口二、FutureTask三、使用 Callable 和 Future四、小结(FutureTask核心原理) 一、Future 接口 当 call()方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用 Future 对象。 将 Future 视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable 返回）。Future 基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写 5 种方法，这
JUC并发编程之FutureTask任务
ldcaws的专栏
10-10 263
一个接口请求要获取多个服务的数据时，则可以通过多线程的方式处理，利用FutureTask获取结果数据。 FutureTast代码示例： 通过多线程+FutureTask实现获取多个服务的数据 在这里插入代码片 自定义FutureTask代码示例： 在这里插入代码片 ...
FutureTask简介
u014516601的博客
06-04 1169
FutureTask的介绍以及使用
Callable、Future与FutureTask
文章中资料均可获取，有需要请添加yunduoa2019即可
09-26 372
通常来说，我们使用Runnable和Thread来创建一个新的线程。 但是它们有一个弊端，就是run方法是没有返回值的。而有时候我们希望开启一个线程去执行一个任务,并且这个任务执行完成后有一个返回值。 JDK提供了Callable 接口与Future 类为我们解决这个问题，这也是所谓的“异步"模型。 Callable接口 Callable与Runnable类似，同样是只有一个抽象方法的函数式接口。不同的是，Callable提供的方法是有返回值的，而且支持泛型。 那一般是怎么使用Callab.
Java多线程Callable和Future接口区别
08-19
"Java多线程Callable和Future接口区别" Java多线程Callable和Future接口是Java语言中两个非常重要的接口，它们都是Java多线程编程中使用的接口，用于描述异步计算的结果。在JavaSE5中引入的Callable是一个具有类型...
Callable和Future.doc
12-25
Callable和Future详解： Callable和Runnable有几点不同: (1)Callable规定的方法是call(),而Runnable规定的方法是run()； (2)call()方法可抛出异常，而run()方法是不能抛出异常的。 (3)Runnable不会返回结果，...
java多线程Future和Callable类示例分享
09-02
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有...今天我们就来研究下Future和Callable的实现方法
java通过Callable和Future来接收线程池的执行结果
08-25
Java通过Callable和Future来接收线程池的执行结果 Java中的线程池执行结果获取一直是一个棘手的问题，对于直接继承Thread的方式或实现Runnable接口的方式，都无法获取到线程执行的返回结果。如果线程在执行过程中...
FutureTask介绍及使用
闵浮龙的博客
03-31 4万+
Future Future是一个接口，它定义了5个方法： boolean cancel(boolean mayInterruptIfRunning); boolean isCancelled(); boolean isDone(); V get() throws InterruptedException, ExecutionException; 简单说明一下接口定义 boolean can...
Java FutureTask理解
yulongfei的专栏
05-21 1万+
尊敬原创作者，转载请注明出处： http://blog.csdn.net/gemmem/article/details/8956703 FutureTask是为了弥补Thread的不足而设计的，它可以让程序员准确地知道线程什么时候执行完成并获得到线程执行完成后返回的结果（如果有需要）。 java.util.concurrent 类 FutureTask java.lang.Ob
关于监控线程池运行状态的一些api
sunshine-zwq的博客
01-15 4249
// 创建一个线程池，线程数corePoolSize为5 Executor executor = Executors.newScheduledThreadPool(5); // 把线程Runnable放到线程池运行 executor.execute(new Runnalbe(){ @Override public void run() { System.out.println("执行线
FutureTask的用法及两种常用的使用场景
linchunquan的专栏
03-28 3万+
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法
java多线程之Callable+Future+FutureTask原理详解和简单使用
一颗小陨石的博客
01-27 1560
一、Runnable和Callabke Runnable是一个接口，只声明了一个run()方法，此方法为void类型，所以只能执行无返回值的任务。 public interface Runnable { public abstract void run(); } Callable是java.util.concurrent包下的一个接口，提供了一个call()方法: @Functional...
Java中的Runnable、Callable、Future、FutureTask的区别与示例
热门推荐
Mr.Simple的专栏
05-01 4万+
Java中的Runnable、Callable、Future、FutureTask的区别与示例
2022最新Java线程池原理讲解
波波烤鸭的博客
01-21 6531
Java线程池核心原理讲解
使用 FutrueTask 和 Callable 实现多线程
实践求真知
03-22 343
一点睛 要创建一个线程，可以继承自Thread类，或者实现Runnable接口，但JUC还提供了另外一种方式，通过Callable + FutureTask创建并使用线程。 1 FutureTask Future是JDK提供用于处理多线程环境异步问题的一种模式，而FutrueTask就是对Future模式的一种实现。下面通过一段对话来理解什么是“Futura模式”。 老板：“小王，把会议纪要整理好给我。” 小王：“好的，没问题。” 随后，小王立刻开始整理，几分...
FutureTest
wenwentana的博客
08-07 131
import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; public class FutureTest { public static void main(String[] args) { Future<String> action = acti...
runnable和callable future
最新发布
04-30
Runnable和Callable Future都是Java中的线程执行方式。 Runnable是Java中常见的线程接口之一，它定义了一个无返回值、没有抛出异常的run() 方法，可以由线程去实现具体的任务。通过实现Runnable接口，Java中的线程可以实现多任务处理，较为简单易懂。 Callable Future也是Java中的线程接口之一，它不仅可以定义一个有返回值的call()方法，还可以抛出异常。通过实现Callable Future 接口，Java中的线程可以更加灵活地进行多任务处理，并且可以返回执行结果。在这个执行结果的基础上，可以实现比较复杂的线程交互逻辑。 Callable Future相较于Runnable而言的优点就是可以返回执行结果，而且异常处理更加方便，因为它可以在call()方法中直接抛出异常，而Runnable则需要通过其他方式来进行异常处理。除此之外，Callable Future还可以通过Future接口来异步获取执行结果，这使得多线程编程更加方便。 因此，在开发中，可以根据需要选择使用Runnable或Callable Future，平衡编程难度和效率。有时候只需简单的多线程执行任务，使用Runnable更加合适；而在多线程之间需要相互交互，并需要返回执行结果的情况下，Callable Future则更加优秀。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

晓呆同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值