Як асинхронно викликати метод на Java

Нещодавно я переглядав goroutine Go і думав, що було б непогано мати щось подібне на Java. Наскільки я шукав поширений спосіб паралелізації виклику методу - це зробити щось на кшталт:

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

Це не дуже елегантно. Чи є кращий спосіб зробити це? Мені потрібно було таке рішення в проекті, тому я вирішив реалізувати власний клас обгортки навколо виклику методу async.

Я опублікував свій клас обгортки в 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);

трохи трохи коротше , ніж створення потоку (завдання є Callable або Runnable)

Ви можете використовувати синтаксис 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від кактусів :

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