Javaでメソッドを非同期に呼び出す方法

私は最近Goのgoroutinesを見ていて、Javaに似たものがあればいいと思いました。私がメソッド呼び出しを並列化する一般的な方法を検索した限り、次のようなことをすることです：

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

それはあまりエレガントではありません。これを行うより良い方法はありますか？プロジェクトでそのようなソリューションが必要だったので、非同期メソッド呼び出しの周りに独自のラッパークラスを実装することにしました。

J-Goでラッパークラスを公開しました。しかし、それが良い解決策かどうかはわかりません。使い方は簡単です：

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

以下の冗長：

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

内部的にはRunnableを実装するクラスを使用しており、Reflectionの作業を行って正しいメソッドオブジェクトを取得し、それを呼び出しています。

私の小さなライブラリと、Javaでこのような非同期メソッド呼び出しを行うことについて、いくつかの意見が欲しいです。安全ですか？すでにもっと簡単な方法はありますか？

私はあなたを行うためのよりクリーンな方法があることを発見しました

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

（少なくともJava 8では）、ラムダ式を使用して次のように短縮できます。

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

JSで関数を作成するのと同じくらい簡単です！

パッケージjava.util.concurrent.CompletableFutureで利用可能なJava 8で導入されたCompletableFutureは、非同期呼び出しを行うために使用できます。

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

クラスも検討することをお勧めしjava.util.concurrent.FutureTaskます。

Java 5以降を使用している場合、FutureTaskは「キャンセル可能な非同期計算」のターンキー実装です。

java.util.concurrentパッケージには、さらに豊富な非同期実行スケジューリング動作（たとえば、ScheduledExecutorService）がFutureTaskありますが、必要なすべての機能を備えている場合があります。

私がFutureTask利用できるようになって以来、例として挙げた最初のコードパターンを使用することはもはやお勧めできないとまで言ってもいいでしょう。（Java 5以降を使用していると想定しています。）

そのためにReflectionを使用するという考えは好きではありません。
いくつかのリファクタリングで欠落しているだけでなく、によって拒否される可能性もありますSecurityManager。

FutureTaskjava.util.concurrentパッケージの他のオプションと同様、優れたオプションです。
簡単なタスクの私のお気に入り：

    Executors.newSingleThreadExecutor().submit(task);

少しスレッドを作成するよりも少し短い（タスクが呼び出し可能かRunnableをあります）

CompletableFutureにJava8構文を使用できます。これにより、非同期関数を呼び出した結果に基づいて、追加の非同期計算を実行できます。

例えば：

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

詳細については、この記事をご覧ください

jcabi-aspectsおよびAspectJ @Asyncからの注釈を使用できます。

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

を呼び出すsave()と、新しいスレッドが開始され、その本体が実行されます。メインスレッドは、の結果を待たずに続行しsave()ます。

これには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);
}

リファレンス：https : //spring.io/guides/gs/async-method/

Javaは非同期メソッドを呼び出すための素晴らしい方法も提供します。でjava.util.concurrentの我々は持っているExecutorServiceの同じことをやってするのに役立ちます。このようにオブジェクトを初期化します-

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

そして、次のような関数を呼び出します

asyncExecutor.execute(() -> {

                        TimeUnit.SECONDS.sleep(3L);}

それはおそらく本当の解決策ではありませんが、現在、Java 8では、ラムダ式を使用してこのコードを少なくとも少し見栄えよくすることができます。

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

そして、あなたはこれを一行で行うことさえできます、それでもそれをかなり読みやすくします。

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

CactoosAsyncFuncから使用できます。

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

これは、バックグラウンドで実行され、結果がで利用できるようになりますget()ようにFuture。

これは実際には関係ありませんが、matches（）などのメソッドを非同期に呼び出す場合は、次のようにします。

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

    });
}

次に、非同期メソッドを呼び出すために使用します。

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

私はこれをテストしましたが、うまくいきます。彼らが「非同期の方法」のために来ただけなら、それが他の人を助けるかもしれないと思っただけです。

EAによって作成されたAsync-Await用の素敵なライブラリもあります：https : //github.com/electronicarts/ea-async

彼らのReadmeから：

EA非同期

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

EA非同期なし

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