Diferencia entre invocable y ejecutable en Java

java.lang.Runnable es una interfaz que debe implementar una clase cuyas instancias están destinadas a ser ejecutadas por un hilo. Hay dos formas de iniciar un nuevo subproceso: Subclase Subproceso e implementar Runnable. No es necesario subclasificar Thread cuando una tarea se puede realizar anulando solo el método run( ) de Runnable.

La interfaz invocable y la interfaz ejecutable se utilizan para encapsular tareas que se supone que debe ejecutar otro subproceso.

Sin embargo, las instancias Runnable pueden ejecutarse mediante la clase Thread y ExecutorService, pero las instancias Callable solo pueden ejecutarse a través de ExecutorService.

Analicemos las diferencias entre las dos interfaces anteriores tal como se definen discutiéndolas individualmente más adelante y concluyendo las principales diferencias en un formato tabular.

Interfaz invocable 

En una interfaz invocable que básicamente arroja una excepción verificada y devuelve algunos resultados. Esta es una de las principales diferencias entre la próxima interfaz Runnable en la que no se devuelve ningún valor. En esta interfaz , simplemente calcula un resultado; de lo contrario, arroja una excepción si no puede hacerlo.

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

1. Se declara en el paquete ‘ java.util.concurrent ‘ .
2. Esta interfaz también contiene un único método sin argumentos, llamado método call ().
3. No podemos crear un hilo pasando callable como parámetro.
4. Callable puede devolver resultados. El método call() de Callable contiene la cláusula «throws Exception», por lo que podemos propagar más fácilmente las excepciones verificadas.

Ejemplo:

// 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());
    }
}

Producción:

Hello World

Interfaz ejecutable 

Cuando se usa un objeto que implementa esta interfaz para crear un subproceso, iniciar el subproceso hace que se llame al método de ejecución del objeto en un subproceso de ejecución independiente. El general. El contrato de este método run() es que puede realizar cualquier acción. 

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

• java.lang.Runnable es una interfaz y define solo un método llamado run(). 
• Representa una tarea en Java que ejecuta Thread.
• Hay dos formas de iniciar un nuevo hilo usando Runnable, una es implementando la interfaz Runnable y otra es subclasificando la clase Thread.
• Runnable no puede devolver el resultado del cálculo, que es esencial si está realizando alguna tarea informática en otro subproceso, y Runnable no puede generar excepciones marcadas.

Ejemplo

// 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);
    }
}