Java >> Tutoriel Java >  >> Java

Différences entre les méthodes submit() et execute() en Java

Java

méthodes submit() vs execute() en Java

Ici, nous verrons comment submit() diffère de la méthode execute() en Java ?

méthode submit()

  • Cette méthode est disponible dans le package java.util.concurrent.
  • soumettre() est utilisée pour soumettre une tâche à ThreadPool.
  • Cette méthode est une méthode surchargée.
  • méthode de soumission() accepte une tâche exécutable ou appelable (c'est-à-dire que cette méthode ne prend qu'un seul argument, qu'elle soit exécutable ou appelable).
  • soumettre() est une méthode statique de l'interface ExecutorService donc cette méthode est également accessible avec le nom de classe.
  • Le type de retour de cette méthode est un objet Future, elle renvoie donc un objet de type Future qui contient le calcul des résultats en attente.
  • L'interface ExecutorService est une interface enfant d'Executor.
  • La syntaxe de la méthode submit() est donné ci-dessous :
    Future f_obj = ExecutorService_obj . submit(new Runnable(){});
Future f_obj = ExecutorService_obj . submit(new Callable(){});
  • Nous devrions opter pour submit() si nous voulons calculer un plus grand nombre de calculs comme calculer la valeur de la tarte, etc. et renvoyer les résultats dans le calcul.

Exemple :Submit() pour accepter la tâche exécutable 

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

Sortie 

Submitting a task by using submit() method
null

Exemple :Submit() pour accepter une tâche appelable 

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

Sortie 

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

Ici, nous verrons comment submit() diffère de la méthode execute() en Java ?

méthode execute()

  • Cette méthode est disponible dans le package java.util.concurrent.
  • méthode execute() est utilisé pour exécuter une tâche sur ThreadPool.
  • méthode execute() accepte uniquement Runnable (c'est-à-dire que cette méthode ne prend qu'un seul argument et qu'elle est Runnable et qu'elle n'accepte pas les tâches Callable comme la méthode submit()).
  • exécuter() est une méthode statique de l'interface Executor donc cette méthode est également accessible avec le nom de la classe.
  • Le type de retour de cette méthode est void donc elle ne retourne rien et ne donnera aucun résultat.
  • L'interface Executor est une interface parente de ExecutorService.
  • Interface exécuteur déclarée execute(Runnable) méthode dont le but principal est de séparer la tâche de son exécution.
  • La syntaxe de la méthode execute() est donnée ci-dessous :
    ExecutorService_obj . execute(new Runnable(){});
  • Nous devrions opter pour execute() si nous voulons exécuter notre code par thread de travail du pool de threads et ne retourne rien.

Exemple : 

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

Sortie 

Submitting a task by using execute() method

Balise Java