Jak asynchronicznie wywołać metodę w Javie

Ostatnio przyglądałem się gorutynom Go i pomyślałem, że fajnie byłoby mieć coś podobnego w Javie. O ile szukałem, powszechnym sposobem zrównoleglenia wywołania metody jest zrobienie czegoś takiego:

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

To niezbyt eleganckie. Czy jest lepszy sposób na zrobienie tego? Potrzebowałem takiego rozwiązania w projekcie, więc zdecydowałem się zaimplementować własną klasę opakowującą wokół wywołania metody asynchronicznej.

Opublikowałem moją klasę wrapper w J-Go . Ale nie wiem, czy to dobre rozwiązanie. Użycie jest proste:

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

lub mniej szczegółowe:

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

Wewnętrznie używam klasy, która implementuje Runnable i wykonuję trochę pracy Reflection, aby uzyskać poprawny obiekt metody i wywołać go.

Chcę uzyskać opinię na temat mojej małej biblioteki i na temat wykonywania wywołań metod asynchronicznych w Javie. Czy to jest bezpieczne? Czy jest już prostszy sposób?

Właśnie odkryłem, że istnieje lepszy sposób na zrobienie tego

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

(Przynajmniej w Javie 8) możesz użyć wyrażenia lambda, aby skrócić je do:

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

Tak proste, jak utworzenie funkcji w JS!

Java 8 wprowadziła CompletableFuture dostępną w pakiecie java.util.concurrent.CompletableFuture, można użyć do wykonania połączenia asynchronicznego:

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

Możesz również rozważyć klasę java.util.concurrent.FutureTask.

Jeśli używasz języka Java 5 lub nowszego, FutureTask jest gotową do realizacji implementacją „asynchronicznych obliczeń z możliwością anulowania”.

W java.util.concurrentpakiecie dostępne są jeszcze bogatsze zachowania planowania wykonywania asynchronicznego (na przykład ScheduledExecutorService), ale FutureTaskmogą mieć wszystkie wymagane funkcje.

Posunąłbym się nawet do stwierdzenia, że ​​nie jest już wskazane używanie pierwszego wzorca kodu, który podałeś jako przykład, odkąd FutureTaskstał się dostępny. (Zakładając, że korzystasz z Java 5 lub nowszej).

Nie podoba mi się pomysł wykorzystania do tego Reflection.
Nie tylko niebezpieczne, że brakuje go w niektórych refaktoryzacjach, ale można temu zaprzeczyć SecurityManager.

FutureTaskjest dobrą opcją, podobnie jak inne opcje z pakietu java.util.concurrent.
Mój ulubiony do prostych zadań:

    Executors.newSingleThreadExecutor().submit(task);

trochę krócej niż tworzenie wątku (zadanie jest wywoływalne lub uruchamialne)

Możesz użyć składni Java8 dla CompletableFuture, w ten sposób możesz wykonać dodatkowe obliczenia asynchroniczne w oparciu o wynik wywołania funkcji asynchronicznej.

na przykład:

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

Więcej szczegółów można znaleźć w tym artykule

Możesz użyć @Asyncadnotacji z jcabi-Aspekty i AspectJ:

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

Kiedy wywołujesz save(), nowy wątek rozpoczyna się i wykonuje swoje ciało. Twój główny wątek jest kontynuowany bez czekania na wynik save().

Możesz do tego użyć Future-AsyncResult.

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

Źródła: https://spring.io/guides/gs/async-method/

Java zapewnia również przyjemny sposób wywoływania metod asynchronicznych. w java.util.concurrent mamy ExecutorService który pomaga w tym samym. Zainicjuj swój obiekt w ten sposób -

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

a następnie wywołaj funkcję taką jak-

asyncExecutor.execute(() -> {

                        TimeUnit.SECONDS.sleep(3L);}

Prawdopodobnie nie jest to prawdziwe rozwiązanie, ale teraz - w Javie 8 - możesz sprawić, by ten kod wyglądał przynajmniej trochę lepiej, używając wyrażenia lambda.

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

Możesz to nawet zrobić w jednej linii, nadal mając ją całkiem czytelną.

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

Możesz użyć AsyncFuncod Cactoos :

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

Zostanie wykonany w tle, a wynik będzie dostępny get()jako plik Future.

Nie jest to tak naprawdę powiązane, ale gdybym miał asynchronicznie wywołać metodę, np. Mecze (), użyłbym:

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

    });
}

Następnie do wywołania metody asynchronicznej użyłbym:

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

Przetestowałem to i działa. Pomyślałem, że może to pomóc innym, jeśli przyjdą po „metodę asynchroniczną”.

Jest też fajna biblioteka dla Async-Await stworzona przez EA: https://github.com/electronicarts/ea-async

Z ich pliku Readme:

Dzięki 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);
    }
}

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