Quels sont les moyens de ne pas attendre l'exécution d'un bloc de code ou d'une méthode?

Question

Quels sont les bons moyens/pratiques/implémentation/stratégies (ou peu importe comment) pour de ne pas attendre que le bloc de code/méthode pour terminer l'exécution en Java?

On suppose la méthode suivante:

private void myMethod() 
{ 
    // Some lines of code here 
    ..... 
    ..... 
    ..... 

    anotherMethod(); // or this could be a code block 

    // Again some lines of code here 
    ..... 
    ..... 
    ..... 
} 

Dans ce cas, je pense myMethod() ne devrait pas attendre code pour terminer l'exécution de anotherMethod(). Je peux également assurer ici que les lignes suivantes de code ne dépendent pas de quoi que ce soit s'exécuter dans anotherMethod().

Answer 1

Vous pouvez le démarrer dans un autre thread s'il n'y a pas de dépendance.

new Thread(new Runnable(){ 

     public void run(){ 
      anotherMethod(); 
     } 

}).start(); 

Answer 2

Si vous voulez invoquer la méthode dans le même fil, la méthode elle-même doit fournir un asynchrone (à savoir non-bloquant) la mise en œuvre. Habituellement, cela implique de renvoyer une sorte de rappel tel qu'un Future, que vous pouvez interroger/interroger plus tard pour récupérer le résultat actuel. Un exemple de ceci est le ExecutorService.submit() appels - le code que vous fournissez sera exécuté, mais dans un thread d'arrière-plan vous laissant libre d'appeler d'autres méthodes dans l'intervalle.

J'ai mis en gras le mot invoquer auparavant, car fondamentalement, le seul moyen de faire fonctionner deux choses à la fois en Java consiste à utiliser plusieurs threads. Donc la méthode/bloc de code/quoi que ce soit devra être exécutée dans un thread d'arrière-plan d'une manière ou d'une autre - habituellement cela est géré pour vous dans une méthode asynchrone en utilisant une sorte de pool de threads. Si la méthode ne fournit pas d'interface asynchrone, la seule façon d'exécuter sa logique dans un autre thread est de générer ce thread vous-même, comme le suggère org.life.java.

Answer 3

Utilisez

Executor executor = Executors.newSingleThreadExecutor(); 
executor.execute(new Runnable() { 
    @Override 
    public void run() { 
     anotherMethod(); 
    } 
}); 
// this is called automatically when the object is gc-ed, 
// but you should not rely on this, hence the explicit call 
executor.shutdown(); 

Pour citer Effective Java:

Non seulement devrait vous abstenir d'écrire vos propres files d'attente, mais vous devrait normalement se garder de travailler directement avec des fils. L'abstraction de clé n'est plus Thread, qui a servi à la fois l'unité de travail et le mécanisme l'exécutant. Maintenant, l'unité de travail et le mécanisme sont séparés. L'abstraction clé est l'unité de travail, appelée tâche. Il existe deux types de tâches: Runnable et son cousin proche, Callable (qui est comme Runnable, sauf qu'il renvoie une valeur). Le mécanisme général d'exécution des tâches est le sous-sereur . Si vous pensez en termes de tâches et laissez un service d'exécution les exécuter pour vous, vous obtenez une grande flexibilité en termes de sélection des politiques d'exécution appropriées. En substance, le cadre d'exécution exécute pour l'exécution ce que les cadres ont fait pour l'agrégation.

Notez que vous feriez mieux de créer votre exécuteur testamentaire une seule fois, le stocker dans un champ d'instance et de le réutiliser (et le mettre hors tension après)

Si vous utilisez dans JavaEE 6 ou au printemps, vous pouvez annoter votre anotherMethod() avec @Asynchronous et le conteneur commencera une nouvelle discussion pour vous.