Diferencias entre submit () y ejecutar () en Java

sometemos () vs Ejecutar () métodos en Java : Aquí, vamos a aprender ¿cuáles son las diferencias entre el presente () y ejecutar () método en el lenguaje de programación Java ?

submit () () vs ejecutar métodos en Java

Aquí, vamos a ver cómo presentar () difiere del método de ejecución () en Java?

submit () Método

  • Este método está disponible en java.util.concurrent class.
  • submit () método se utiliza para enviar una tarea a ThreadPool .
  • Este método es un método sobrecargado.
  • submit () método acepta tarea ya sea Ejecutable o tarea que se puede llamar (es decir Este método sólo toma un argumento o bien es Ejecutable o rescatable).
  • submit () es un método class de ExecutorService package lo que este método se puede acceder con el nombre de clase también.
  • El tipo class de este método es un objeto Future así que tipo static Future objeto que contiene cálculo de los resultados pendientes.
  • ExecutorService interface es un niño de return Ejecutor.
  • La sintaxis de submit () método se da a continuación:
    Future f_obj = ExecutorService_obj . submit(new Runnable(){});
    Future f_obj = ExecutorService_obj . submit(new Callable(){});

  • Deberíamos ir return submit () si queremos calcular un mayor número de cálculos como el cálculo del valor de pastel, etc y interface resulta en la computación.

Ejemplo: Presentar () para aceptar tarea Ejecutable

// Java program to demonstrate the behavior of submit() method 
// of ExecutorService interface
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
public class SubmitATaskBySubmitMethod {
public static void main(String[] args) throws Exception {
// Allow one thread from ThreadPool
ExecutorService exe_ser = Executors.newFixedThreadPool(1);
// By using submit() we are accepting Runnable task
Future f = exe_ser.submit(new Runnable() {
// Override run() method and will define a job inside it
public void run() {
System.out.println("Submitting a task by using submit() method");
}
});
// This method will return null if task has finished perfectly
// (i.e. without any error)
System.out.println(f.get());
}
}

salida

Submitting a task by using submit() method
null

Ejemplo: Presentar () para aceptar tarea Callable

// Java program to demonstrate the behavior of submit() method 
// of ExecutorService interface
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
public class SubmitATaskBySubmitMethod {
public static void main(String[] args) throws Exception {
// Allow one thread from ThreadPool
ExecutorService exe_ser = Executors.newFixedThreadPool(1);
// By using submit() we are accepting Callable task
Future f = exe_ser.submit(new Callable() {
// Override call() method and will define a job inside it
public Object call() {
System.out.println("Submitting a Callable task by using submit() method");
return "Callable Task";
}
});
// This method will return null if task has finished perfectly
// (i.e. without any error)
System.out.println(f.get());
}
}

salida

Submitting a Callable task by using submit() method
Callable Task

Aquí, vamos a ver cómo presentar () difiere del método execute () en Java?

ejecutar () Método

  • Este método está disponible en java.util.concurrent interface.
  • ejecutar () método se utiliza para ejecutar una tarea a ThreadPool .
  • método execute () sólo acepta Ejecutable (es decir Este método sólo toma un argumento y es Ejecutable y no acepta la tarea que se puede llamar como presentar como método ()).
  • ejecutar () es un método for de Ejecutor return lo que este método se puede acceder con el nombre class también.
  • El tipo package de este método es class por lo que no devuelve nada y no dará ningún resultado.
  • Ejecutor static es una matriz de interface ExecutorService.
  • Ejecutor class declaró ejecutar (Ejecutable) método cuyo objetivo es separar return la tarea de su ejecución.
  • La sintaxis del método execute () se da a continuación:
    ExecutorService_obj . execute(new Runnable(){});

  • Deberíamos ir void ejecutar () si queremos ejecutar nuestro código por el subproceso de trabajo del conjunto de subprocesos y no lo hace interface nada .

Ejemplo:

// Java program to demonstrate the behavior of execute() method 
// of Executor interface
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SubmitATaskByExecuteMethod {
public static void main(String[] args) throws Exception {
// Allow one thread from ThreadPool
ExecutorService exe_ser = Executors.newFixedThreadPool(1);
// By using execute() we are accepting Runnable task
exe_ser.execute(new Runnable() {
// Override run() method and will define a job inside it
public void run() {
System.out.println("Submitting a task by using execute() method");
}
});
// This method performs previous submitted task before termination
exe_ser.shutdown();
}
}

salida

Submitting a task by using execute() method


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *