如何在Java中異步調用方法

Question

最近我一直在尋找Go's 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的類，做一些反思工作，以得到正確的方法對象，並調用它。

我想要一些關於我的小型庫和關於在Java中使用這種異步方法調用的主題的看法。它安全嗎？有沒有更簡單的方法？

Answer 1

你也不妨考慮類java.util.concurrent.FutureTask。

如果您使用的是Java 5或更高版本，則FutureTask是「可取消的異步計算」的交鑰匙實現。

java.util.concurrent包中有更豐富的異步執行調度行爲（例如，ScheduledExecutorService），但FutureTask可能具有您需要的所有功能。

我甚至會說自從FutureTask變得可用以後，不再推薦使用第一種代碼模式作爲示例。 （假設你使用的是Java 5或更高版本。）

Answer 2

我不喜歡使用Reflection的想法。
不僅在一些重構中丟失它是很危險的，但它也可以被SecurityManager拒絕。

FutureTask作爲java.util.concurrent包中的其他選項是一個不錯的選擇。
我簡單的任務最喜歡的：

Executors.newSingleThreadExecutor().submit(task); 

小位不是創建一個線程（任務是可贖回或一個Runnable）

Answer 3

您可以使用@Async註釋從jcabi-aspects和AspectJ短：

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

當你調用save()時，一個新的線程啓動並執行它的主體。您的主線程不會等待save()的結果。

Answer 4

我才發現，原來有做一個更清潔的方式您

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

（至少在Java中8），你可以使用lambda表達式來縮短到：

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

由於簡單的做在JS中的功能！

Answer 5

這並沒有真正相關，但如果我要異步調用方法，例如比賽（），我會用：

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

我測試了這一點，它的工作原理。只是認爲它可以幫助別人，如果他們只是爲了「異步方法」而來。

Answer 6

您可以使用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/

Answer 7

它可能不是一個真正的解決方案，但現在 - 在Java中8 - 你至少可以更好一點使用lambda表達式使此代碼的樣子。

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

而且你甚至可以在一行中做到這一點，仍然有它的可讀性。

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

Answer 8

您可以使用AsyncFunc從Cactoos：

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

它會在後臺執行，結果將在get()可作爲一個Future。

Answer 9

您可以對CompletableFuture使用Java8語法，這樣您可以根據調用異步函數的結果執行其他異步計算。

例如：

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

更多細節可以在包java.util.concurrent.CompletableFuture可用此article

Answer 10

的Java 8中引入CompletableFuture發現，可以用來進行非同步呼叫：

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