Diferencia entre ExecutorService ejecutar() y enviar() método en Java

La interfaz ExecutorService amplía Executor al agregar métodos que ayudan a administrar y controlar la ejecución de subprocesos. Se define en el paquete java.util.concurrent . Define métodos que ejecutan los hilos que devuelven resultados, un conjunto de hilos y que determinan el estado de apagado. En este artículo, veremos la diferencia entre los dos métodos llamados ejecutar() y enviar(). 

En Java, para realizar tareas asincrónicas, se implementa la interfaz ejecutable . Para hacer esto, una de esas interfaces disponible es la interfaz Executor . La interfaz del ejecutor contiene el método execute() . Aparte de eso, hay otra interfaz disponible que es la interfaz ExecutorService que amplía la interfaz del ejecutor. Este método contiene el método submit(). La siguiente imagen ilustra la relación entre estas dos interfaces. 
 

Método de ejecución: esta función ejecuta el comando dado en algún momento en el futuro. El comando puede ejecutarse en un subproceso nuevo, en un subproceso agrupado o en el subproceso de llamada, a discreción de la implementación del Ejecutor. Este método es un método vacío, lo que significa que no devuelve ninguna función. Una vez asignada la tarea en el método execute(), no obtendremos ninguna respuesta y podemos olvidarnos de la tarea. La siguiente es una implementación del método de ejecución. 
 

// Java program to demonstrate
// the behavior of the
// execute() method
 
import java.util.concurrent.*;
public class GFG {
 
    public static void main(String[] args)
        throws Exception
    {
 
        // Creating the object of the
        // Executor Service
        ExecutorService executorService
            = Executors.newSingleThreadExecutor();
 
        // execute() method cannot return
        // anything because it's return type
        // is void.
 
        // By using execute(), we are accepting
        // a Runnable task
        executorService.execute(new Runnable() {
 
            // Override the run method
            public void run()
            {
                System.out.println(
                    "This is execute() "
                    + "method example");
            }
        });
 
        // This method performs all the
        // previouslu submitted tasks
        // before termination
        executorService.shutdown();
    }
}

Producción: 

Método de envío: esta función ejecuta el comando dado en algún momento en el futuro. El comando puede ejecutarse en un subproceso nuevo, en un subproceso agrupado o en el subproceso de llamada, a discreción de la implementación del Ejecutor. A diferencia del método de ejecución, este método devuelve un futuro. En Java, el futuro representa el resultado de un cálculo asíncrono. El objeto futuro se usa para manejar la tarea después de que haya comenzado la ejecución. Por lo tanto, cuando necesitamos el resultado de la ejecución, podemos usar el método enviar() del objeto futuro. Para obtener el resultado, podemos usar los métodos get() en Future. El método get() devuelve un objetosi llamamos al método get() antes de que se complete la tarea, se bloqueará hasta que el resultado esté listo y puede arrojar una excepción verificada o, si la tarea se completa, entonces el objeto futuro contiene un resultado que se devuelve y luego se puede usar más tarde . La siguiente es una implementación del método de envío:
 

// Java program to demonstrate
// the behavior of the
// submit() method
 
import java.util.concurrent.*;
public class GFG {
    public static void main(String[] args)
        throws Exception
    {
 
        // Creating the object of the
        // Executor service interface
        ExecutorService executorService
            = Executors.newFixedThreadPool(1);
 
        // submit() method can return the
        // result of the computation
        // because it has a return type of Future.
 
        // By using submit(), we are
        // accepting a Callable task
        Future obj
            = executorService.submit(new Callable() {
 
                  // Overriding the call method
                  public Object call()
                  {
                      System.out.println(
                          "This is submit() "
                          + "method example");
 
                      return "Returning Callable "
                          + "Task Result";
                  }
              });
 
        // This method will return the result
        // if the task has finished perfectly.
        // The submit() method returns a
        // Java Future object which is
        // used to check when the Runnable
        // has completed.
        // As it implements Future,
        // get() method is called
        // to get the result
        System.out.println(obj.get());
         executorService.shutdown();
    }
}

Producción:  

La siguiente tabla muestra la diferencia entre el método de ejecución y el método de envío: