So rufen Sie eine Methode in Java asynchron auf

Ich habe mir in letzter Zeit Go's Goroutinen angesehen und dachte, es wäre schön, etwas Ähnliches in Java zu haben. Soweit ich gesucht habe, besteht die übliche Methode zur Parallelisierung eines Methodenaufrufs darin, Folgendes zu tun:

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

Das ist nicht sehr elegant. Gibt es einen besseren Weg, dies zu tun? Ich brauchte eine solche Lösung in einem Projekt und beschloss, meine eigene Wrapper-Klasse um einen asynchronen Methodenaufruf herum zu implementieren.

Ich habe meine Wrapper-Klasse in J-Go veröffentlicht . Aber ich weiß nicht, ob es eine gute Lösung ist. Die Verwendung ist einfach:

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

oder weniger ausführlich:

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

Intern verwende ich eine Klasse, die Runnable implementiert und einige Reflection-Arbeiten ausführt, um das richtige Methodenobjekt abzurufen und aufzurufen.

Ich möchte eine Meinung zu meiner winzigen Bibliothek und zum Thema asynchrone Methodenaufrufe wie diese in Java. Ist es sicher? Gibt es schon einen einfacheren Weg?

Ich habe gerade herausgefunden, dass es einen saubereren Weg gibt, dies zu tun

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

(Zumindest in Java 8) können Sie einen Lambda-Ausdruck verwenden, um ihn zu verkürzen:

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

So einfach wie das Erstellen einer Funktion in JS!

Java 8 führte CompletableFuture ein, das im Paket java.util.concurrent.CompletableFuture verfügbar ist und verwendet werden kann, um einen asynchronen Aufruf durchzuführen:

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

Vielleicht möchten Sie auch die Klasse berücksichtigen java.util.concurrent.FutureTask .

Wenn Sie Java 5 oder höher verwenden, FutureTask eine schlüsselfertige Implementierung von "Eine stornierbare asynchrone Berechnung".

Das java.util.concurrentPaket bietet (z. B. ScheduledExecutorService) noch umfassendere Verhaltensweisen bei der asynchronen AusführungsplanungFutureTask möglicherweise über alle erforderlichen Funktionen.

Ich würde sogar so weit gehen zu sagen, dass es nicht mehr ratsam ist, das erste Codemuster zu verwenden, das Sie als Beispiel angegeben haben, seit es FutureTaskverfügbar ist. (Angenommen, Sie verwenden Java 5 oder höher.)

Ich mag die Idee, Reflection dafür zu verwenden, nicht.
Es ist nicht nur gefährlich, es bei einem Refactoring zu verpassen, sondern kann auch von abgelehnt werden SecurityManager.

FutureTaskist eine gute Option wie die anderen Optionen aus dem Paket java.util.concurrent.
Mein Favorit für einfache Aufgaben:

    Executors.newSingleThreadExecutor().submit(task);

etwas kürzer als das Erstellen eines Threads (Aufgabe ist Callable oder Runnable)

Sie können die Java8-Syntax für CompletableFuture verwenden. Auf diese Weise können Sie zusätzliche asynchrone Berechnungen basierend auf dem Ergebnis des Aufrufs einer asynchronen Funktion durchführen.

beispielsweise:

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

Weitere Details finden Sie in diesem Artikel

Sie können @AsyncAnmerkungen aus jcabi-Aspekten und AspectJ verwenden:

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

Wenn Sie aufrufen save(), startet ein neuer Thread und führt seinen Body aus. Ihr Haupt-Thread wird fortgesetzt, ohne auf das Ergebnis von zu warten save().

Hierfür können Sie Future-AsyncResult verwenden.

@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);
}

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

Java bietet auch eine gute Möglichkeit, asynchrone Methoden aufzurufen. In java.util.concurrent haben wir ExecutorService , der dabei hilft, dasselbe zu tun. Initialisieren Sie Ihr Objekt so -

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

und rufen Sie dann die Funktion like-

asyncExecutor.execute(() -> {

                        TimeUnit.SECONDS.sleep(3L);}

Es ist wahrscheinlich keine echte Lösung, aber jetzt - in Java 8 - können Sie diesen Code mit dem Lambda-Ausdruck zumindest ein wenig besser aussehen lassen.

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

Und Sie könnten dies sogar in einer Zeile tun, wobei es immer noch ziemlich lesbar ist.

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

Sie können AsyncFuncvon Cactoos verwenden :

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

Es wird im Hintergrund ausgeführt werden , und das Ergebnis wird in verfügbar sein get()als Future.

Dies hängt nicht wirklich zusammen, aber wenn ich eine Methode asynchron aufrufen würde, z. B. match (), würde ich Folgendes verwenden:

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

    });
}

Um dann die asynchrone Methode aufzurufen, würde ich verwenden:

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

Ich habe das getestet und es funktioniert. Ich dachte nur, es könnte anderen helfen, wenn sie nur für die "asynchrone Methode" kommen.

Es gibt auch eine schöne Bibliothek für Async-Await, die von EA erstellt wurde: https://github.com/electronicarts/ea-async

Aus ihrer Readme:

Mit 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);
    }
}

Ohne 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);
            });
    }
}