Как асинхронно вызвать метод в Java

В последнее время я смотрел горутины Go и подумал, что было бы неплохо иметь что-то подобное в 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, и выполняю некоторую работу по отражению, чтобы получить правильный объект метода и вызвать его.

Я хочу получить некоторое мнение о моей крошечной библиотеке и о том, как делать такие вызовы асинхронных методов в Java. Это безопасно? Есть ли уже более простой способ?

Я только что обнаружил, что есть более чистый способ

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

(По крайней мере, в Java 8) вы можете использовать лямбда-выражение, чтобы сократить его до:

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

Так же просто, как создать функцию на JS!

Java 8 представила CompletableFuture, доступную в пакете java.util.concurrent.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.

FutureTask- хороший вариант, как и другие варианты из пакета java.util.concurrent.
Мои любимые для простых задач:

    Executors.newSingleThreadExecutor().submit(task);

немного короче, чем создание потока (задача - вызываемая или выполняемая)

Вы можете использовать синтаксис Java8 для CompletableFuture, таким образом вы можете выполнять дополнительные асинхронные вычисления на основе результата вызова асинхронной функции.

например:

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

Более подробную информацию можно найти в этой статье.

Вы можете использовать @Asyncаннотацию из jcabi-аспектов и AspectJ:

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

Вы можете использовать AsyncFuncот Cactoos :

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

Он будет выполнен в фоновом режиме, а результат будет доступен в get()виде файла Future.

На самом деле это не связано, но если бы я должен был асинхронно вызвать метод, например, match (), я бы использовал:

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

Я проверил это, и он работает. Просто подумал, что это может помочь другим, если они просто пришли за «асинхронным методом».

Еще есть хорошая библиотека для Async-Await, созданная EA: https://github.com/electronicarts/ea-async

Из их Readme:

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

Без 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);
            });
    }
}