Comment appeler une méthode de manière asynchrone en Java ?

Question

J'ai examiné Les goroutines de Go et j'ai pensé qu'il serait intéressant d'avoir quelque chose de similaire en Java. D'après mes recherches, la façon la plus courante de paralléliser un appel de méthode est de faire quelque chose comme :

final String x = "somethingelse";
new Thread(new Runnable() {
           public void run() {
                x.matches("something");             
    }
}).start();

Ce n'est pas très élégant. Existe-t-il une meilleure façon de procéder ? J'avais besoin d'une telle solution dans un projet et j'ai donc décidé d'implémenter ma propre classe enveloppante autour d'un appel de méthode asynchrone.

J'ai publié ma classe enveloppante dans J-Go . Mais je ne sais pas si c'est une bonne solution. L'utilisation est simple :

SampleClass obj = ...
FutureResult<Integer> res = ...
Go go = new Go(obj);
go.callLater(res, "intReturningMethod", 10);         //10 is a Integer method parameter
//... Do something else
//...
System.out.println("Result: "+res.get());           //Blocks until intReturningMethod returns

ou moins verbeux :

Go.with(obj).callLater("myRandomMethod");
//... Go away
if (Go.lastResult().isReady())                //Blocks until myRandomMethod has ended
    System.out.println("Method is finished!");

En interne, j'utilise une classe qui implémente Runnable et j'effectue un travail de Reflection pour obtenir l'objet de la méthode correcte et l'invoquer.

J'aimerais avoir un avis sur ma petite bibliothèque et sur le fait de faire des appels de méthodes asynchrones comme celui-ci en Java. Est-ce sûr ? Existe-t-il déjà un moyen plus simple ?

Answer 1

Je viens de découvrir qu'il existe une façon plus propre de faire votre

new Thread(new Runnable() {
    public void run() {
        //Do whatever
    }
}).start();

(Au moins en Java 8), vous pouvez utiliser une expression lambda pour l'abréger :

new Thread(() -> {
    //Do whatever
}).start();

C'est aussi simple que de créer une fonction en langage JS !

Answer 2

Java 8 a introduit CompletableFuture disponible dans le paquet java.util.concurrent.CompletableFuture, qui peut être utilisé pour faire un appel asynchrone :

CompletableFuture.runAsync(() -> {
    // method call or code to be asynch.
});

Answer 3

Vous pouvez également prendre en compte la classe java.util.concurrent.FutureTask .

Si vous utilisez Java 5 ou une version ultérieure, FutureTask est une implémentation clé en main de "A cancellable asynchronous computation".

Il existe des comportements d'ordonnancement d'exécution asynchrones encore plus riches dans le module java.util.concurrent (par exemple, ScheduledExecutorService ), mais FutureTask peut contenir toutes les fonctionnalités dont vous avez besoin.

J'irais même jusqu'à dire qu'il n'est plus conseillé d'utiliser le premier modèle de code que vous avez donné en exemple depuis que FutureTask est devenu disponible. (En supposant que vous utilisiez Java 5 ou une version ultérieure).

Answer 4

Je n'aime pas l'idée d'utiliser Reflection pour cela.
Il n'est pas seulement dangereux de l'oublier lors d'une refonte, mais il peut également être refusé par SecurityManager .

FutureTask est une bonne option comme les autres options du package java.util.concurrent.
Mon préféré pour les tâches simples :

    Executors.newSingleThreadExecutor().submit(task);

petit un peu plus court que la création d'un Thread (la tâche est un Callable ou un Runnable)

Answer 5

Vous pouvez utiliser la syntaxe Java8 pour CompletableFuture, de cette façon vous pouvez effectuer des calculs asynchrones supplémentaires basés sur le résultat de l'appel d'une fonction asynchrone.

par exemple :

 CompletableFuture.supplyAsync(this::findSomeData)
                     .thenApply(this:: intReturningMethod)
                     .thenAccept(this::notify);

Pour plus de détails, voir article