Come chiamare in modo asincrono un metodo in Java

Ultimamente ho guardato le goroutine di Go e ho pensato che sarebbe stato bello avere qualcosa di simile in Java. Per quanto ho cercato, il modo comune per parallelizzare una chiamata al metodo è fare qualcosa come:

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

Non è molto elegante. C'è un modo migliore per farlo? Avevo bisogno di una tale soluzione in un progetto, quindi ho deciso di implementare la mia classe wrapper attorno a una chiamata al metodo asincrono.

Ho pubblicato la mia classe wrapper in J-Go . Ma non so se sia una buona soluzione. L'utilizzo è semplice:

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

o meno prolisso:

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

Internamente sto usando una classe che implementa Runnable e faccio un po 'di lavoro di riflessione per ottenere l'oggetto del metodo corretto e invocarlo.

Voglio qualche opinione sulla mia minuscola libreria e sull'argomento di effettuare chiamate di metodi asincroni come questa in Java. È sicuro? Esiste già un modo più semplice?

Ho appena scoperto che esiste un modo più pulito per fare il tuo

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

(Almeno in Java 8), puoi utilizzare un'espressione lambda per abbreviarla in:

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

Semplice come creare una funzione in JS!

Java 8 ha introdotto CompletableFuture disponibile nel pacchetto java.util.concurrent.CompletableFuture, può essere utilizzato per effettuare una chiamata asincrona:

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

Potresti considerare anche la classe java.util.concurrent.FutureTask.

Se utilizzi Java 5 o versioni successive, FutureTask è un'implementazione chiavi in ​​mano di "Un calcolo asincrono cancellabile".

Nel java.util.concurrentpacchetto sono disponibili comportamenti di pianificazione dell'esecuzione asincrona ancora più ricchi (ad esempio, ScheduledExecutorService), ma FutureTaskpotrebbero avere tutte le funzionalità necessarie.

Mi spingerei addirittura a dire che non è più consigliabile utilizzare il primo modello di codice che hai fornito come esempio da quando è FutureTaskdiventato disponibile. (Supponendo che tu sia su Java 5 o successivo.)

Non mi piace l'idea di usare Reflection per questo.
Non solo pericoloso per averlo perso in qualche refactoring, ma può anche essere negato SecurityManager.

FutureTaskè una buona opzione come le altre opzioni del pacchetto java.util.concurrent.
Il mio preferito per compiti semplici:

    Executors.newSingleThreadExecutor().submit(task);

un po 'più breve della creazione di un thread (l'attività è un chiamabile o eseguibile)

È possibile utilizzare la sintassi Java8 per CompletableFuture, in questo modo è possibile eseguire calcoli asincroni aggiuntivi basati sul risultato della chiamata di una funzione asincrona.

per esempio:

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

Maggiori dettagli possono essere trovati in questo articolo

È possibile utilizzare l' @Asyncannotazione da jcabi- effects e AspectJ:

public class Foo {
  @Async
  public void save() {
    // to be executed in the background
  }
}

Quando chiami save(), un nuovo thread inizia ed esegue il suo corpo. Il tuo thread principale continua senza attendere il risultato di save().

Puoi usare Future-AsyncResult per questo.

@Async
public Future<Page> findPage(String page) throws InterruptedException {
    System.out.println("Looking up " + page);
    Page results = restTemplate.getForObject("http://graph.facebook.com/" + page, Page.class);
    Thread.sleep(1000L);
    return new AsyncResult<Page>(results);
}

Riferimento: https://spring.io/guides/gs/async-method/

Java fornisce anche un bel modo per chiamare metodi asincroni. in java.util.concurrent abbiamo ExecutorService che aiuta a fare lo stesso. Inizializza il tuo oggetto in questo modo:

 private ExecutorService asyncExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

e quindi chiama la funzione come-

asyncExecutor.execute(() -> {

                        TimeUnit.SECONDS.sleep(3L);}

Probabilmente non è una soluzione reale, ma ora, in Java 8, puoi rendere questo codice almeno un po 'migliore usando l'espressione lambda.

final String x = "somethingelse";
new Thread(() -> {
        x.matches("something");             
    }
).start();

E potresti anche farlo in una riga, comunque abbastanza leggibile.

new Thread(() -> x.matches("something")).start();

Puoi usare AsyncFuncda Cactoos :

boolean matches = new AsyncFunc(
  x -> x.matches("something")
).apply("The text").get();

Sarà eseguito in background e il risultato sarà disponibile in get()come Future.

Questo non è realmente correlato, ma se dovessi chiamare in modo asincrono un metodo, ad esempio match (), userei:

private final static ExecutorService service = Executors.newFixedThreadPool(10);
public static Future<Boolean> matches(final String x, final String y) {
    return service.submit(new Callable<Boolean>() {

        @Override
        public Boolean call() throws Exception {
            return x.matches(y);
        }

    });
}

Quindi per chiamare il metodo asincrono userei:

String x = "somethingelse";
try {
    System.out.println("Matches: "+matches(x, "something").get());
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

L'ho provato e funziona. Ho solo pensato che potrebbe aiutare gli altri se venissero solo per il "metodo asincrono".

C'è anche una bella libreria per Async-Await creata da EA: https://github.com/electronicarts/ea-async

Dal loro file Leggimi:

Con EA Async

import static com.ea.async.Async.await;
import static java.util.concurrent.CompletableFuture.completedFuture;

public class Store
{
    public CompletableFuture<Boolean> buyItem(String itemTypeId, int cost)
    {
        if(!await(bank.decrement(cost))) {
            return completedFuture(false);
        }
        await(inventory.giveItem(itemTypeId));
        return completedFuture(true);
    }
}

Senza EA Async

import static java.util.concurrent.CompletableFuture.completedFuture;

public class Store
{
    public CompletableFuture<Boolean> buyItem(String itemTypeId, int cost)
    {
        return bank.decrement(cost)
            .thenCompose(result -> {
                if(!result) {
                    return completedFuture(false);
                }
                return inventory.giveItem(itemTypeId).thenApply(res -> true);
            });
    }
}