Java Callable和Runnable的区别用法及代码示例

Runnable是一个由类实现的接口，该类的实例旨在由线程执行。有两种方法可以启动新线程 - 子类化 Thread 并实现 Runnable。当任务可以仅通过覆盖来完成时，不需要 sub-classing 线程跑步() Runnable 的方法。

Callable interface and Runnable interface are used to encapsulate tasks supposed to be executed by another thread.

However, Runnable instances can be run by Thread class as well as ExecutorService but Callable instances can only be executed via ExecutorService.

让我们通过稍后单独讨论上述两个接口的定义来讨论它们之间的差异，然后以表格格式得出主要差异。

可调用接口

在一个可调用接口中，本质上抛出一个已检查的异常并返回一些结果。这是即将推出的 Runnable 接口之间的主要区别之一，其中不返回任何值。在这个接口中,它只是计算结果，如果无法计算结果，则会抛出异常。

public interface Callable<V> 
{
  V call() throws exception ;
}

它在‘java.util.concurrent'包。
该接口还包含一个单一的、无参数的方法，称为call()方法
我们不能通过传递 callable 作为参数来创建线程。
Callable 可以返回结果。 Callable 的 call() 方法包含 “throws Exception” 子句，因此我们可以轻松地进一步传播已检查的异常。

例子：

Java


// Java Program to illustrate Callable interface 
// Importing classes from java.util package 
import java.util.Random;  
import java.util.concurrent.Callable;  
import java.util.concurrent.Future;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
  
// Class
// Implementing the Callable interface
class CallableMessage implements Callable<String>{
  public String call() throws Exception{
      return "Hello World!";
  }  
}
public class CallableExample{
  static ExecutorService executor = Executors.newFixedThreadPool(2);
    public static void main(String[] args) throws Exception{
        CallableMessage task = new CallableMessage();
         Future<String> message = executor.submit(task);
         System.out.println(message.get().toString());
    }
}

输出：

Hello World

可运行的接口

当使用实现此接口的对象创建线程时，启动线程会导致在单独执行的线程中调用对象的 run 方法。一般。这个run()方法的合同是它可以采取任何行动。

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

java.lang.Runnable是一个接口，仅定义一个方法，称为run()。
它代表Java中由线程执行的任务。
使用 Runnable 启动新线程有两种方法，一种是实现 Runnable 接口，另一种是子类化 Thread 类。
Runnable 无法返回计算结果，如果您在另一个线程中执行某些计算任务，这一点至关重要，并且 Runnable 无法抛出已检查的异常。

示例

Java


// Java Program to implement Runnable interface
// Importing FileNotFound class from
// input output classes bundle
import java.io.FileNotFoundException;
import java.util.concurrent.*;
// Class
// Implementing the Runnable interface 
class RunnableImpl implements Runnable {
  public void run()
  {
    System.out.println("Hello World from a different thread than Main");
  }
}
public class RunnableExample{
    static ExecutorService executor = Executors.newFixedThreadPool(2);
  public static void main(String[] args){
          // Creating and running runnable task using Thread class
          RunnableImpl task = new RunnableImpl();
        Thread thread = new Thread(task);
          thread.start();
          // Creating and running runnable task using Executor Service.
          executor.submit(task);
    }
}

可运行的接口	可调用接口
自 Java 1.0 以来，它是 java.lang 包的一部分	它是java.util.concurrent 从 Java 1.5 开始打包。
它无法返回计算结果。	它可以返回任务并行处理的结果。
它不能抛出已检查的异常。	它可以抛出一个已检查的异常。
在可运行接口中，需要重写Java中的run()方法。	为了使用Callable，您需要覆盖call()

相关用法

注：本文由纯净天空筛选整理自taresh2112大神的英文原创作品 Difference Between Callable and Runnable in Java。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。