Java多线程 - Runnable接口和Callable接口的区别

已于 2022-10-09 18:57:53 修改
阅读量3.2k 收藏 20
点赞数 6
分类专栏： 【Java-并发编程】 文章标签： java 开发语言 后端
于 2022-02-21 12:23:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42764468/article/details/123044515
版权

文章目录


Runnable接口源码： 

@FunctionalInterface
public interface Runnable {
    // 这个run()方法返回值为void，没有受检异常的异常声明，出现异常只能内部捕获
    public abstract void run();
}

Callable接口源码：

@FunctionalInterface
public interface Callable<V> {
	// 这个call()方法有返回值，且声明了受检异常，可以直接抛出Exception异常
    V call() throws Exception;
}

Runnable接口和Callable接口的区别：

(1) Runnable接口中的唯一抽象方法run()方法没有返回值，Callable接口中的唯一抽象方法call()方法有返回值；

(2) Runnable接口的run()方法没有受检异常的异常声明，即异常只能在内部捕获，不能继续上抛， Callable接口的call()方法声明了受检异常，可直接抛出Exception异常，并且可以不予捕获；

(3) Callable实例不能和Runnable实例一样，直接作为Thread线程实例的target来使用；

(4) 异步执行任务在大多数情况下是通过线程池去提交的，而Runnable接口和Callable接口都可以应用于线程池；

(5) Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！

注意：异步执行任务在大多数情况下是通过线程池去提交的，而很少通过创建一个新的线程去提交（即通过Thread类的方式执行start()方法）。

下面实例解析以上不同点：

1. Runnable接口实例

首先，通过实现Runnable接口的方式创建一个异步执行任务：

public class RunnableTask implements Runnable  {
    // 线程体：需要线程异步执行的任务
    @Override
    public void run() {
        System.out.println("实现Runnable接口来编写异步执行任务");

        // run()方法内出现异常，只能捕获不能直接抛出
        try {
            Thread.sleep(1000) ;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

方式1：通过Thread类创建线程，将Runnable接口的实现类作为Thread线程实例的target来使用，执行异步任务

public class RunnableDemo {
    public static void main(String[] args) {
        Runnable target = new RunnableTask();
        // 通过Thread类创建一个新线程，并启动
        Thread thread = new Thread(target);
        thread.start();
    }
}

方式2：通过线程池创建线程，并提交异步执行任务

public class RunnableDemo2 {
    // 通过线程池创建3个线程
    private static ExecutorService executorService = Executors.newFixedThreadPool(3);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1、通过线程池的execute()方法提交异步执行任务，没有返回结果
        executorService.execute(new RunnableTaskDemo());

        // 2、通过线程池的submit()方法提交异步执行任务，有返回结果
        Future<?> submit = executorService.submit(new RunnableTaskDemo());
        // 获取返回结果
        System.out.println(submit.get()); // null
    }
}

2. Callable接口原理

Callable接口实例没有办法作为Thread线程实例的target来使用。既然如此，那么该如何使用Callable接口创建线程呢？因此需要一个在Callable接口与Thread线程之间起到搭桥作用的重要接口。

1、RunnableFuture接口源码：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

RunnableFuture接口实现了2个目标：

(1) RunnableFuture通过继承Runnable接口，从而保证了其实例可以作为Thread线程实例的target目标；
(2) RunnableFuture通过继承Future接口，从而保证了可以获取未来的异步执行结果。

那有些同学可能疑惑了，Future接口又是什么？Future接口至少提供了3大功能：

(1) 能够取消异步执行中的任务；
(2) 判断异步任务是否执行完成；
(3) 获取异步任务完成后的执行结果；

2、Future接口的源码：

public interface Future<V> {
	
    // 取消异步执行中的任务
    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    // 判断异步任务是否执行成功
    boolean isDone();

    // 获取异步任务完成后的结果
    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future接口中的方法：

  • get()：获取异步任务执行的结果。注意，这个方法的调用是阻塞性的。如果异步任务没有执行完成，异步结果获取线程（调用线程）会一直被阻塞，一直阻塞到异步任务执行完成，其异步结果返回给调用线程。

  • get(Long timeout,TimeUnit unit)：设置时限，（调用线程）阻塞性地获取异步任务执行的结果。该方法的调用也是阻塞性的，但是结果获取线程（调用线程）会有一个阻塞时长限制，不会无限制地阻塞和等待，如果其阻塞时间超过设定的timeout时间，该方法将抛出异常，调用线程可捕获此异常。

  • boolean isDone()：获取异步任务的执行状态。如果任务执行结束，就返回true。

  • boolean isCancelled()：获取异步任务的取消状态。如果任务完成前被取消，就返回true。

  • boolean cancel(boolean mayInterruptRunning)：取消异步任务的执行。

总体来说，Future是一个对异步任务进行交互、操作的接口。但是Future仅仅是一个接口，通过它没有办法直接完成对异步任务的操作，JDK提供了一个默认的实现类——FutureTask。

3、FutureTask类 ：

RunnableFuture只是一个接口，无法直接创建对象，如果需要创建对象，就需用到它的实现类——FutureTask。所以说，FutureTask类才是真正的在Thread与Callable之间搭桥的类。FutureTask类实现了RunnableFuture接口，而RunnableFuture接口又继承了Runnable接口和Future接口，因此它可以作为Thread线程实例的target目标，也可以获取异步执行结果；

public class FutureTask<V> implements RunnableFuture<V> {
    
}

FutureTask内部有一个Callable类型的成员——callable实例属性：

private Callable<V> callable;

callable实例属性用来保存并发执行的Callable类型的任务，并且callable实例属性需要在FutureTask实例构造时进行初始化：

public FutureTask(Callable<V> callable) {
    if (callable == null) throw new NullPointerException();
    // callable实例属性需要在FutureTask实例构造时进行初始化
    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
}

FutureTask类实现了Runnable接口，在其run()方法的实现版本中会执行callable成员的call()方法：

public void run() {
    if (state != NEW ||!UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                // 在run()方法中执行call()方法
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                // ...
            }
            if (ran) set(result);
        }
    } finally {
        // ...
    }
}

FutureTask内部还有另一个非常重要的Object类型的成员——outcome实例属性：

private Object outcome;

FutureTask的outcome实例属性用于保存callable成员call()方法的异步执行结果。在FutureTask类的run()方法完成callable成员的call()方法的执行之后，其结果将被保存在outcome实例属性中，供FutureTask类的get()方法获取。
在这里插入图片描述

3. Callnable接口实例

首先，通过实现Runnable接口的方式创建一个异步执行任务：

public class CallableTaskDemo implements Callable {
    // call()方法有返回值，并且可以抛出Exception异常
    @Override
    public String call() throws Exception {
        System.out.println("实现Callable接口来编写异步执行任务");
        Thread.sleep(1000);
        return "返回线程执行结果";
    }
}

方式1：通过Thread类创建线程执行异步任务

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建异步执任务实例
        Callable callable = new CallableTaskDemo();
        // 初始化callable实例属性
        FutureTask futureTask = new FutureTask(callable);
        // 创建线程执行异步任务
        Thread thread = new Thread(futureTask);
        thread.start();

        System.out.println("获取异步执行任务结果："+futureTask.get());// 获取异步执行任务结果：返回线程执行结果
    }
}

方式2：通过线程池创建线程，并提交异步执行任务：

public class CallableDemo2 {
    // 通过线程池创建3个线程
    private static ExecutorService executorService = Executors.newFixedThreadPool(3);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 通过线程池的submit()方法提交异步执行任务，有返回结果
        Future submit = executorService.submit(new CallableTaskDemo());
        // 获取返回结果
        System.out.println(submit.get());
    }
}

4. FutureTask是什么？

Future是一个对异步任务进行交互、操作的接口。但是Future仅仅是一个接口，通过它没有办法直接完成对异步任务的操作，JDK提供了一个默认的实现类——FutureTask。

对于Calleble来说，Future和FutureTask均可以用来获取任务执行结果，不过Future是个接口，FutureTask是Future的具体实现，而且FutureTask还间接实现了Runnable接口，也就是说FutureTask可以作为Runnable任务提交给线程池。

5. 线程池中 submit() 和 execute() 方法有什么区别？

两者都是将一个线程任务添加到线程池中并执行；
1、excutor没有返回值，submit有返回值，并且返回执行结果Future对象
2、excutor不能提交Callable任务，只能提交Runnable任务，submit两者任务都可以提交
3、在submit中提交Runnable任务，会返回执行结果Future对象，但是Future调用get方法将返回null（Runnable没有返回值）

我一直在流浪
关注
专栏目录
Java并发编程 —— Runnable和Callable
debug
03-29 912
1. Runnable和Callable 2. Future和FutureTask 1. Runnable和Callable Java多线程有两个重要的接口，Runnable和Callable，分别提供了一个call方法和一个run方法 相同点 两者都是接口 两者都可以用来编写多线程程序 两者都可以调用Thread.start()来启动线程 不同点 两个最大的不同点就是：实现...
Java多线程Callable和Future接口区别
08-19
"Java多线程Callable和Future接口区别" Java多线程Callable和Future接口是Java语言中两个非常重要的接口，它们都是Java多线程编程中使用的接口，用于描述异步计算的结果。在JavaSE5中引入的Callable是一个具有类型...
深入理解Runnable接口及其在Java并发编程中的应用
m0_46413639的博客
06-03 461
Java中的Runnable接口是并发编程的基础，它提供了一种简单的方式来创建可运行的任务，这些任务可以在单独的线程中执行。当创建一个线程时，可以将实现了Runnable接口的对象作为参数传递给Thread类的构造函数，然后调用线程的start()方法，这样就可以在新的线程中执行run()方法中的代码。通过实现Runnable接口，我们可以在继承其他类的同时，还能让类的实例被线程执行，从而避免了继承上的限制。实现Runnable接口的类只负责定义任务，而线程的创建和管理的逻辑可以由其他类负责。
Runnable和Callable的区别
最新发布
liu_dong_kang的博客
08-02 622
callable /ˈkɔːləbəl/ 可调用，随时可偿还的。从字面意义上可以看出来，二者的差别，后者突出结果的可返回。runnable /ˈrʌnəbl/ 可运行。
Callable接口和Runnable接口
08-21 928
Callable接口和Runnable接口相似，区别就是Callable需要实现call方法，而Runnable需要实现run方法；并且，call方法还可以返回任何对象，无论是什么对象，JVM都会当作Object来处理。但是如果使用了泛型，我们就不用每次都对Object进行转换了。   Runnable和Callable都是接口 不同之处： 1.Callable可以返回一个类型V，而R
Java之Callable和Runnable
码莎拉蒂
11-14 2874
1 接口定义 1) Callable接口 public interface Callable<V> { V call() throws Exception; } 2) Runnable接口 public interface Runnable { public abstract void run(); } 2 不同点和相同点 1）相同点 都...
Java多线程：Runnable与Callable的区别和原理
隐风的博客
10-10 708
总的来说，Runnable和Callable都是用于实现多线程的工具，但它们的设计目的和使用场景是不同的。Runnable更适合用于执行简单的、不需要返回结果的任务，而Callable更适合用于需要返回计算结果的任务。在编写多线程程序时，我们需要根据实际需求选择适当的接口。在Java多线程编程中，我们经常使用Runnable和Callable接口来创建并执行线程。这两个接口都是Java.lang包中的部分，并且都用于实现多线程。在本文中，我们将深入探讨这两种接口的差异以及它们的工作原理。
java线程实现runnable接口和callable接口的区别
05-31
Java中实现多线程有两种方式，一种是实现Runnable接口，另一种是实现Callable接口。它们之间的主要区别在于返回值和抛出异常的不同。 Runnable接口中只有一个run()方法，该方法没有返回值，而且不能抛出受检查的...
Java多线程实现Callable接口
09-02
通过以上知识点，我们可以看到Callable接口在Java多线程中的应用，它可以方便地处理返回值，并且与ExecutorService结合，提供了强大的并发处理能力。在实际开发中，特别是在大数据处理、计算密集型任务等场景下，...
Java多线程Callable接口
01-20
Runnable是执行工作的独立任务，但是它不返回任何值，如果你希望任务在完成时能够返回一个值，那么可以实现Callable接口而不是Runnable接口。在Java SE5中引入的Callable是一种具有类型参数的泛型，它的类型参数表示...
Java多线程之Callable接口的实现
08-27
Java多线程之Callable接口的实现 Java中的多线程编程是指在一个程序中同时运行多个线程，以提高程序的...Callable接口是Java多线程编程中的一种重要接口，它提供了返回结果和抛出异常的功能，广泛应用于实际开发中。
Runnable和Callable的区别？
2401_84909321的博客
07-14 618
接口提供了更灵活和强大的功能，但相应地也增加了使用的复杂度。因此，在面试中，我们需要根据具体的应用场景和需求来选择合适的接口。在使用方法和功能上的差异。在实际开发中，选择哪个接口主要取决于是否需要返回值和是否需要在方法外捕获和处理异常。：面试官还会关注面试者是否了解这两个接口在实际开发中的应用场景，例如哪些情况下更适合使用。：结合具体的代码示例来说明这两个接口的使用方法和区别，这样可以使回答更加生动和具体。：对于技术难点和面试官可能关注的细节进行深入剖析，展示自己对这两个接口的深入理解。
java中Runnable和Callable的区别
V539413949的博客
04-29 1112
java中Runnable和Callable的区别 在java的多线程开发中Runnable一直以来都是多线程的核心，而Callable是java1.5添加进来的一个增强版本。 本文我们会详细探讨Runnable和Callable的区别。 运行机制 首先看下Runnable和Callable的接口定义： @FunctionalInterface public interface Runnable { /** * When an object implementing interface &
java callable_java中Runnable和Callable的区别
weixin_29266679的博客
02-18 102
在java的多线程开发中Runnable一直以来都是多线程的核心，而Callable是java1.5添加进来的一个增强版本。本文我们会详细探讨Runnable和Callable的区别。运行机制首先看下Runnable和Callable的接口定义：@FunctionalInterfacepublic interface Runnable {/*** When an object implementi...
java多线程—Runnable、Thread、Callable区别
没长正
08-12 1144
java多线程—Runnable、Thread、Callable区别 阅读目录 多线程编程优点第一种实现方法—继承Thread类第二种实现方法—实现Runnable接口第三种—实现Callable接口总结参考 回到顶部 多线程编程优点 进程之间不能共享内存，但线程之间共享内存非常容易。 系统创建线程所分配的资源相对创建进程而言，代价非常小。
Java学习之Callable接口和Runnable接口的不同
只须一笑不须愁X的博客
11-02 333
Java学习之Callable接口和Runnable接口的不同 1.Callable接口 返回结果并可能抛出异常的任务。实现器定义了一个没有call参数的单一方法。 Callable接口类似于Runnable，因为两者都是为实例可能由另一个线程执行的类设计的。然而，Runnable不会返回结果，也不能抛出选中的异常。 2.Runnable接口 Runnable接口应由实例打算由线程执行的任何类实现。类必须定义一个没有参数的方法，称为run。 此接口旨在为希望在活动期间执行代码的对象提供通用协议。例如，Run
java的runnable和callable
memory
07-31 761
1. Runnable接口，只声明了一个 run() 方法，且无返回值 2.Callabble，泛型接口，只声明了一个call() 方法，返回类型是传递进来的 V 类型，且会抛出异常 public interface Runnable { public abstract void run(); } public interface Callable<V> { ...
介绍java 中 Runnable 和 Callable
neweastsun的专栏
01-16 1035
介绍java 中 Runnable 和 Callable 从java早期开始，多线程已经就是其主要特性之一。Runable接口是表现多线程任务核心接口，Callable是java1.5之后引入的新街口。 本文，我们探讨下这两个接口之间的差别。 ##　执行机制 这两个接口都代表能被多线程执行的任务，Runable任务可以使用Thread和ExecutorService执行，而Callable只能使用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我一直在流浪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值