JavaCallable 和 Runnable 的区别

Java.lang.Runnable是一个由类实现的接口，该类的实例旨在由线程执行。有两种方法可以启动一个新线程——子类Thread和实现Runnable 。当一个任务可以通过只覆盖Runnable 的run( )方法来完成时，不需要对Thread进行子类化。

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

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

可调用接口

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

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

1. 它在“ Java.util.concurrent ”包中声明。
2. 此接口还包含一个无参数的方法，称为call()方法
3. 我们不能通过传递 callable 作为参数来创建线程。
4. 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.FutureTask;  
   
// Class
// Implementing the Callable interface
class CallableExample implements Callable {
     
  // Main driver method  
   public static void main(String args[])
   {
     
      // public Object call() throws Exception  
    
        
       Random generator = new Random();  
   
       Integer randomNumber = generator.nextInt(5);  
   
          
       Thread.sleep(randomNumber * 1000);  
   
       return randomNumber;  
       }
     
}

可运行界面

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

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

• Java.lang.Runnable是一个接口，只定义了一个名为run() 的方法。
• 它代表Java中由 Thread 执行的任务。
• 有两种方法可以使用 Runnable 启动新线程，一种是通过实现 Runnable 接口，另一种是通过子类化 Thread 类。
• Runnable 无法返回计算结果，如果您在另一个线程中执行某些计算任务，这是必不可少的，并且 Runnable 无法抛出已检查的异常。

例子

Java

// Java Program to implement Runnable interface
  
// Importing FileNotFound class from
// input output classes bundle
import java.io.FileNotFoundException;
  
// Class
// Implementing the Runnable interface 
public class RunnableImpl implements Runnable {
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Run method
        public void run()
        {
            // Display message when the thread executes
            System.out.println(
                Thread.currentThread().getName()
                + ", executing run() method!");
  
            // Try block to check if any exception occurs
            try {
                throw new FileNotFoundException();
            }
  
            // Catch block to handle the exception
            catch (FileNotFoundException e) {
  
                // Display message
                System.out.println("Must catch here!");
  
                // Print the line number
                // where exception occured
                e.printStackTrace();
            }
  
            // Here forcefully it
            int rem = 1 / 0;
        }
    }

Runnable interface	Callable interface
It is a part of java.lang package since Java 1.0	It is a part of the java.util.concurrent package since Java 1.5.
It cannot return the return of computation.	It can return the result of the parallel processing of a task.
It cannot throw a checked Exception.	It can throw a checked Exception.
In a runnable interface, one needs to override the run() method in Java.	In order to use Callable, you need to override the call()