JUC（6）Callable与Runnable的区别、Future

最新推荐文章于 2023-10-10 22:48:53 发布
最新推荐文章于 2023-10-10 22:48:53 发布
阅读量331 收藏
点赞数
分类专栏： # 多线程与并发编程 文章标签： Callable Runnable future
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/109996713
版权

文章目录

一、Runnable

  • Runnable应该是我们最熟悉的接口，它只有一个run()函数，用于将耗时操作写在其中，该函数没有返回值。然后使用某个线程去执行该runnable即可实现多线程，Thread类在调用start()函数后就是执行的是Runnable的run()函数。Runnable的声明如下 :
public interface Runnable {
    /*
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

二、Callable(简单)

  • 此部分可以参考https://blog.csdn.net/wang_luwei/article/details/107490047

在这里插入图片描述

  • 创建线程的第三种方式
  • Callable ：可以有返回值；可以抛出异常；与Runnable中的方法不同，run()/call()
  • 两个细节：有缓存、结果需要等待（会阻塞）
  • Callable与Runnable的功能大致相似，Callable中有一个call()函数，但是call()函数有返回值，而Runnable的run()函数不能将结果返回给客户程序。Callable的声明如下 :
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}
  • Callable的使用
package com.wlw.callable;

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

public class CallableTest {

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

        //Callable怎么放入到Thread里面呢？
        //对于Thread运行，只能传入Runnable类型的参数； 我们这是Callable 怎么办呢？
        //在Runnable里面有一个叫做FutureTask的实现类，FutureTask中可以接受Callable参数；
        //这样我们就可以先把Callable 放入到FutureTask中， 再把FutureTask 放入到Thread就可以了。
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask<>( Callable)).start();

        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread);
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start(); //这两个线程只输出了一个call，结果会被缓存，效率高

        Integer o = (Integer)futureTask.get(); 
         //这个get方法可能会被阻塞，如果在cal1方法中是一个耗时的方法，所以一般情况我们会把这个放在最后，或者使用异步通信

        System.out.println(o);
    }
}

class MyThread implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("call");
        return 1024;
    }
}

三、FutureTask（很有用）

  • FutureTask是一个RunnableFuture
public class FutureTask<V> implements RunnableFuture<V>
  • RunnableFuture实现了Runnbale又实现了Futrue这两个接口
public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}
  • 另外FutureTaslk还可以包装Runnable和Callable， 由构造函数注入依赖。
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
 
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }
  • 上面代码块可以看出：Runnable注入会被Executors.callable()函数转换为Callable类型，即FutureTask最终都是执行Callable类型的任务。该适配函数的实现如下 ：
    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }
  • 总结：
    • FutureTask实现Runnable，所以能通过Thread包装执行，
    • FutureTask实现Runnable，所以能通过提交给ExcecuteService来执行，注：ExecuteService：创建线程池实例对象，其中有submit（Runnable）、submit（Callable）方法
    • 还可以直接通过get()函数获取执行结果，该函数会阻塞，直到结果返回。
    • 因此FutureTask是Future也是Runnable，又是包装了的Callable( 如果是Runnable最终也会被转换为Callable )。

四、Callable 接口和 Runnable接口的区别

  1. Callable规定的方法是call()，而Runnable规定的方法是run()
  2. Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
  3. call()方法可抛出异常，而run()方法是不能抛出异常的。
  4. 运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。 它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
  5. 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
  6. Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。

五、异步回调 Future

  • Future 设计的初衷：对将来的某个事件结果进行建模！

  • 异步回调，我们可以想到 ajax（前端 --> 发送ajax异步请求给后端）

  • 看一下jdk文档

    在这里插入图片描述

5.1没有返回值的 runAsync() 异步回调

package com.wlw.future;

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

/**
 *异步调用: CompletableFuture
 *   异步执行.
 *   成功回调
 *   失败回调
 */

public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //发送一个请求，采用的是无返回值的 runAsync() 异步回调
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"==>runAsync 无返回值的异步回调 void");
        });

        System.out.println("1111111111111111");

        completableFuture.get(); //阻塞 的获取等待结果 ，它会等待发送请求之后的执行结果,但是并不影响其他代码的执行
    }
}

5.2有返回值的supplyAsync() 异步回调

package com.wlw.future;

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

public class Demo02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //有返回值的supplyAsync() 异步回调
        //分为成功和失败的回调
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"==>supplyAsync 有返回值的异步回调 Integer");
            int a = 10/0;
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t==>" + t);  //成功回调，得到的正常的返回结果
            System.out.println("u==>" + u); //  抛出异常的 输出的错误信息  u==>java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233; //获取到错误的返回结果
        }).get());
    }
}

5.3与Callable在线程池中的使用

  • Callable对象是可以直接传给线程池的（不需要转换成FutureTask）

  • 线程池.submit （线程池的提交）有返回值，为future : 表示将要执行完任务的结果，就是call()的返回值

  • Future：表示将要完成任务的结果

  • 方法：V get() 以阻塞形式等待Future中的异步处理结果（call()的返回值）

  • 需求：使用两个线程，并发计算1-50，51-100的和，再进行汇总

package com.wlw.thread.threaddemo02;

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

/**
 * Future接口的使用
 * 需求：使用两个线程，并发计算1~50，51~100的和，再进行汇总
 */
public class FutureDemo {
    public static void main(String[] args) throws Exception{
        
        //1.创建线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        
        //2.提交任务
        Future<Integer> future1 = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"计算开始");
                int sum = 0;
                for (int i = 0; i <= 50; i++) {
                    sum += i;
                }
                System.out.println("1~50 计算完毕");
                return sum;
            }
        });
        Future<Integer> future2 = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"计算开始");
                int sum = 0;
                for (int i = 51; i <= 100; i++) {
                    sum += i;
                }
                System.out.println("51~100 计算完毕");
                return sum;
            }
        });

        //3.获取结果(get() 方法要等call() 方法执行完毕，才能返回)
        System.out.println(future1.get()+future2.get());

        //4.关闭线程池
        es.shutdown();
    }
}
/*
执行结果：
pool-1-thread-1计算开始
pool-1-thread-2计算开始
51~100 计算完毕
1~50 计算完毕
5050
*/
悬浮海
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
runnable 和 callable 有什么区别？
m0_68464502的博客
06-05 9827
Callable适用于那些需要返回值或者需要抛出checked Exception的情况，比如对某个任务的计算结果进行处理，或者需要进行网络或IO操作等。但在Callable中，自定义的call()方法可以抛出一个checked Exception，并由其执行者Handler进行捕获并处理。Runnable适用于那些不需要返回值，且不会抛出checked Exception的情况，比如简单的打印输出或者修改一些共享的变量。Runnable的run()方法没有返回值，只是一个void类型的方法。
Callable和Runnable的区别（面试常考），看完就懂
热门推荐
syw_0406的博客
08-26 3万+
Callable和Runnable的区别（面试常考），看完就懂Callable接口测试类Runnable接口测试类两者的区别 Callable 接口 测试类 Runnable 接口 测试类 两者的区别 1、最大的区别，runnable没有返回值，而实现callable接口的任务线程能返回执行结果 2、callable接口实现类中的run方法允许异常向上抛出，可以在内部处理，try catch，但是runnable接口实现类中run方法的异常必须在内部处理，不能抛出 ...
【java】runnable和callable的区别
当白的技术小窝 ( git : https://github.com/canwhite )
12-09 6622
java中runnable和callable的区别
runnable和callable的区别
qq_16570607的博客
03-31 1045
runnable和callable的区别主要在于它们的用途和实现方式。 主要区别： or callable的执行，被ExecutorService执行or作为FeatureTask的参数 or 使用FeatureTask 这里还有一个很好的总结
Runnable和Callable的区别
const_
03-04 1万+
Runnable和Callable的区别Runnable和Callable的区别：ExcutorService中的excutor和submit方法的区别使用场景：FutureTask:ExecutorCompletionService：示例代码：使用CompletionService维护结果：自己创建list维护执行结果： Runnable和Callable的区别： 1、Runnable任务方法是...
JUC并发编程与源码分析视频课.zip
12-16
讲解Thread类、Runnable接口以及Callable和Future接口的基本用法。 2. **同步机制**：深入讲解synchronized关键字的用法，包括对象锁、类锁、同步代码块和同步方法。此外，还会涉及volatile关键字的作用及其与...
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
08-02
- `Callable`接口类似于`Runnable`，但其`call()`方法可以返回一个结果并抛出异常，它是`Future`任务的基础。 3. **并发容器**： - `ConcurrentHashMap`：线程安全的哈希映射表，比`synchronized`的`HashMap`更...
狂神说JUC代码狂神说JUC代码
09-11
2. **Future和Callable**：Callable接口允许我们在任务中返回一个结果，与Runnable相比更加灵活。Future接口则代表Callable任务的执行结果，可以用于获取结果或检查任务是否完成。 3. **锁**： - **synchronized**...
个人学习-JUC-笔记
02-25
- **Callable与Future**：Callable可以返回结果，Future用于获取结果，两者结合能更好地进行线程间的通信。 3. **线程池** - **Executor框架**：Java 5引入的ExecutorService，它管理线程池，提供了更灵活的线程...
Java——JUC
12-29
- `Callable`接口定义了异步任务，返回一个结果，与`Runnable`接口的区别在于`Callable`可以有返回值。 6. **CompletableFuture** - 提供了强大的异步编程模型，可以组合多个异步任务，实现链式调用，并支持多种...
Runnable和Callable的区别和联系
mryang125的博客
08-20 3万+
Java多线程有两个重要的接口，Runnable和Callable，分别提供一个run方法和call方法，二者是有较大差异的。 1）Runnable提供run方法，无法通过throws抛出异常，所有CheckedException必须在run方法内部处理。Callable提供call方法，直接抛出Exception异常。 2）Runnable的run方法无返回值，Callable的call方法...
java并发编程第十课 Callable、Runnable、Future
fegus的博客
05-26 930
第48讲：Callable 和 Runnable 的不同？ 你好，欢迎来到第 48 课时，在本课时我们将讲解 Callable 和 Runnable 的不同。 为什么需要 Callable？Runnable 的缺陷 先来看一下，为什么需要 Callable？要想回答这个问题，我们先来看看现有的 Runnable 有哪些缺陷？ 不能返回一个返回值 第一个缺陷，对于 Runnable 而言，它不能返回一个返回值，虽然可以利用其他的一些办法，比如在 Runnable 方法中写入日志文件或者修改某个共享的对象的办法
Java多线程：Runnable与Callable的区别和原理
最新发布
隐风的博客
10-10 610
总的来说，Runnable和Callable都是用于实现多线程的工具，但它们的设计目的和使用场景是不同的。Runnable更适合用于执行简单的、不需要返回结果的任务，而Callable更适合用于需要返回计算结果的任务。在编写多线程程序时，我们需要根据实际需求选择适当的接口。在Java多线程编程中，我们经常使用Runnable和Callable接口来创建并执行线程。这两个接口都是Java.lang包中的部分，并且都用于实现多线程。在本文中，我们将深入探讨这两种接口的差异以及它们的工作原理。
搞懂 Runnable、Future、Callable、FutureTask 之间的关系，这篇就够了
养歌的博客
01-27 4352
前言 创建线程的两种方式主要有继承 Thread 类 或 实现 Runnable 接口，重写 run 方法，无论我们使用 Thread 还是 Runnable 新建线程，它都无法返回结果值。自从 Jdk1.5 开始，官方提供了 Callable 和 Future, 通过他们就可以获得任务的执行结果。其中 FutureTask 则作为 Future 的实现类。 下面是他们的关系类图： Runnable Thread 类本身也实现了 Runnable 接口，Runnable 接口源码如下： public in
Runnable与Callable区别
kykangyuky的博客
02-23 313
1.接口实现的方法不同 Runnable 需要实现run()方法 Callable 需要实现call()方法 2.返回值不同 Runnable run()方法不允许指定返回值 Callable Call()方法允许指定返回值，返回值是一个泛型，可以通过futureRask.get()方法来获取到线程执行的结果，但是此方法会阻塞主线程的执行，知道子线程任务执行完成并返回结果 3.异常处理 Runnable run()方法不能抛出异常 Callable call()方法允许抛
Callable与Runnable的区别你知道吗？
a1472750149的博客
02-08 3061
JDK版本：JDK11 1. 背景 在平时的开发过程中线程肯定用不少，线程启动执行需要实现 Runnable 类： public class ThreadTest { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { System.out.pri.
Callable,Runnable的区别及用法
披萨大叔的博客
05-19 2万+
编写多线程程序一般有三种方法，Thread,Runnable,Callable.Runnable和Callable的区别是： (1)Callable规定的方法是call()，Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下，直接启动一个线程来执行，而Callable则一般都是提交给ExecuteService来执行。 (2)Callable的任务执
Runnable和Callable
积
01-22 680
Runable都可以在主线程之外单独启一个线程。 Runnable和Callable的区别在于： 使用方式：Runable可直接使用  new Thread(Runable runable).start();来启动一个线程 Callable需要使用FutureTask进行封装，使用new Thread(new FutureTask 返回值：Runable只是单纯的启动一个线程任务，这个线程
多线程之Runnable、Callable和Future的详解和区别
qq_40205337的博客
11-22 1606
Runnable、Callable和Future的详解和区别 在程序运行中，执行的时间和用户的体验是密切相关的，人们不希望用一个经常卡顿的网站或应用，这时候多线程能给程序带来质的提升。 一、Runnable 简介 Runnable接口只有一个抽象的run()方法，此方法是在Thread.start()的时候由JVM调用run方法，创建一个线程，并调用run方法。 例子 public class RunnableTest { public static void main(String[] arg

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

悬浮海

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

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

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

打赏作者

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

抵扣说明：

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

余额充值