Cách gọi không đồng bộ một phương thức trong Java

Gần đây, tôi đã xem xét các goroutines của Go và nghĩ rằng sẽ rất tuyệt nếu có thứ gì đó tương tự trong Java. Theo như tôi đã tìm kiếm, cách phổ biến để song song một cuộc gọi phương thức là thực hiện một số việc như:

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

Đó không phải là rất thanh lịch. Có cách nào tốt hơn để làm điều này không? Tôi cần một giải pháp như vậy trong một dự án vì vậy tôi quyết định triển khai lớp trình bao bọc của riêng mình xung quanh một cuộc gọi phương thức không đồng bộ.

Tôi đã xuất bản lớp trình bao bọc của mình trong J-Go . Nhưng tôi không biết đó có phải là một giải pháp tốt hay không. Cách sử dụng rất đơn giản:

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

hoặc ít dài dòng:

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

Bên trong, tôi đang sử dụng một lớp triển khai Runnable và thực hiện một số công việc Reflection để lấy đối tượng phương thức chính xác và gọi nó.

Tôi muốn một số ý kiến ​​về thư viện nhỏ của tôi và về chủ đề thực hiện các cuộc gọi phương thức không đồng bộ như thế này trong Java. Nó có an toàn không? Đã có một cách đơn giản hơn?

Tôi vừa phát hiện ra rằng có một cách dễ dàng hơn để làm

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

(Ít nhất là trong Java 8), bạn có thể sử dụng biểu thức lambda để rút gọn nó thành:

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

Đơn giản như tạo một hàm trong JS!

Java 8 đã giới thiệu CompletableFuture có sẵn trong gói java.util.concurrent.CompletableFuture, có thể được sử dụng để thực hiện cuộc gọi không đồng bộ:

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

Bạn cũng có thể muốn xem xét lớp học java.util.concurrent.FutureTask.

Nếu bạn đang sử dụng Java 5 trở lên, FutureTask là một triển khai chìa khóa trao tay của "Một phép tính không đồng bộ có thể hủy bỏ".

Thậm chí có nhiều hành vi lập lịch thực thi không đồng bộ phong phú hơn có sẵn trong java.util.concurrentgói (ví dụ ScheduledExecutorService:), nhưng FutureTaskcó thể có tất cả các chức năng bạn yêu cầu.

Tôi thậm chí còn đi xa hơn khi nói rằng không còn nên sử dụng mẫu mã đầu tiên mà bạn đã đưa ra làm ví dụ kể từ khi FutureTaskcó sẵn. (Giả sử bạn đang sử dụng Java 5 trở lên.)

tôi không thích ý tưởng sử dụng Reflection cho việc đó.
Không chỉ nguy hiểm nếu bỏ sót nó trong một số lần tái cấu trúc, mà còn có thể bị từ chối bởi SecurityManager.

FutureTasklà một tùy chọn tốt như các tùy chọn khác từ gói java.util.concurrent.
Yêu thích của tôi cho các nhiệm vụ đơn giản:

    Executors.newSingleThreadExecutor().submit(task);

ít cắn ngắn hơn so với việc tạo ra một chủ đề (nhiệm vụ là một Callable hoặc một Runnable)

Bạn có thể sử dụng cú pháp Java8 cho CompletableFuture, bằng cách này, bạn có thể thực hiện các tính toán không đồng bộ bổ sung dựa trên kết quả từ việc gọi một hàm không đồng bộ.

ví dụ:

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

Thông tin chi tiết có thể được tìm thấy trong bài viết này

Bạn có thể sử dụng @Asyncchú thích từ jcabi-khía cạnh và AspectJ:

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

Khi bạn gọi save(), một luồng mới bắt đầu và thực thi phần thân của nó. Chuỗi chính của bạn tiếp tục mà không cần đợi kết quả của save().

Bạn có thể sử dụng Future-AsyncResult cho việc này.

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

Tham khảo: https://spring.io/guides/gs/async-method/

Java cũng cung cấp một cách hay để gọi các phương thức không đồng bộ. trong java.util.concurrent, chúng tôi có ExecutorService giúp làm điều tương tự. Khởi tạo đối tượng của bạn như thế này -

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

và sau đó gọi hàm như-

asyncExecutor.execute(() -> {

                        TimeUnit.SECONDS.sleep(3L);}

Nó có lẽ không phải là một giải pháp thực sự, nhưng bây giờ - trong Java 8 - Bạn có thể làm cho mã này trông đẹp hơn một chút bằng cách sử dụng biểu thức lambda.

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

Và bạn thậm chí có thể làm điều này trong một dòng, vẫn có thể đọc được.

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

Bạn có thể sử dụng AsyncFunctừ Cactoos :

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

Nó sẽ được thực thi ở chế độ nền và kết quả sẽ có sẵn get()dưới dạng a Future.

Điều này không thực sự liên quan nhưng nếu tôi gọi một phương thức không đồng bộ, ví dụ: match (), tôi sẽ sử dụng:

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

    });
}

Sau đó, để gọi phương thức không đồng bộ, tôi sẽ sử dụng:

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

Tôi đã thử nghiệm điều này và nó hoạt động. Chỉ nghĩ rằng nó có thể giúp ích cho những người khác nếu họ đến với "phương pháp không đồng bộ".

Ngoài ra còn có thư viện tuyệt vời cho Async-Await được tạo bởi EA: https://github.com/electronicarts/ea-async

Từ Readme của họ:

Với 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);
    }
}

Không có 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);
            });
    }
}