将来有结果？

Question

我希望从一个方法中获得结果，该方法可能需要一段时间才能完成并且实际上 return 不是对象，所以我想尽可能有效地处理它。这是我要实现的目标的示例：

    public static void main (String[] args) {
        Object obj = someMethod();

        System.out.println("The object is" + obj + ", wooh!");
    }

    public void callObject() {
        // Sends request for the object
    }

    public void receiveObject(Object object) {
        // Received the object
    }

    public Object someMethod() {
        callObject();
        // delay whilst the object is being received
        // return received object once received, but how?
    }

方法 callObject 将调用以获取对象，但是使用对象调用了不同的方法。我希望 someMethod() 能够调用对象，然后 return 它最终是什么接收，即使实际调用和接收是不同的方法。

我研究过使用 FutureTasks 和 Callables，我认为是前进的方向，我只是不太确定如何实施它。

抱歉，如果我没有很好地解释自己，如有必要，我会提供更多信息。

谢谢！

Answer 1

您可以编写一个方法，异步启动一些较长的运行ning 任务。然后，您将 return 一个未来的对象，它是空的，但在运行ning 长任务完成时会被填充。在其他编程语言中，这称为承诺。

这是一个简单的例子。我创建了一个名为 someLongAsyncOperation 的方法，它执行需要一段时间的操作。为了模拟这个，我在生成答案之前只睡了 3 秒。

import java.util.UUID;
import java.util.concurrent.*;

public class Test {

    private static final ExecutorService executorService = Executors.newSingleThreadExecutor();

    public Future<MyAnswer> someLongAsyncOperation(){

        Future<MyAnswer> future = executorService.submit(() -> {
            Thread.sleep(3000);
            return new MyAnswer(UUID.randomUUID().toString());
        });

        return future;
    }


    public static void main(String[] args) throws Exception {

        System.out.println("calling someLongAsyncOperation ...");
        Future<MyAnswer> future = new Test().someLongAsyncOperation();
        System.out.println("calling someLongAsyncOperation done.");

        // do something else

        System.out.println("wait for answer ...");
        MyAnswer myAnswer = future.get();
        System.out.printf("wait for answer done. Answer is: %s", myAnswer.value);

        executorService.shutdown();
    }

    static class MyAnswer {
        final String value;

        MyAnswer(String value) {
            this.value = value;
        }
    }
  }

如果你执行这个小测试 class，你会看到 someLongAsyncOperation return 很快，但是当调用 future.get(); 时我们等待操作完成。

您现在可以执行一些操作，例如启动多个 longAsyncOperation，这样它们就会运行并行。然后等到全部完成。

这对你来说是一个起点吗？

编辑

您可以这样实施 someMethod：

public MyAnswer someMethod() throws ExecutionException, InterruptedException {
        Future<MyAnswer> future = someLongAsyncOperation(); // kick of async operation
        return future.get(); // wait for result
    }

这将使异步操作再次同步，方法是调用它并等待结果。

EDIT2

这是另一个使用 wait/notify 的例子：

import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test2 {

    private static final ExecutorService executorService = Executors.newSingleThreadExecutor();
    private Object receivedObject;
    private final Object mutex = new Object();

    public static void main (String[] args) throws InterruptedException {
        Object obj = new Test2().someMethod();

        System.out.println("The object is" + obj + ", wooh!");

        executorService.shutdown();
    }

    public void callObject() {

        System.out.println("callObject ...");

        // Sends request for the object asynchronously!
        executorService.submit(() -> {

            // some wait time to simulate slow request
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // provide object to callback
            receiveObject(UUID.randomUUID().toString());
        });

        System.out.println("callObject done.");
    }

    public void receiveObject(Object object) {

        System.out.println("receiveObject ...");

        synchronized (mutex) {
            this.receivedObject = object;
            mutex.notify();
        }

        System.out.println("receiveObject done.");
    }

    public Object someMethod() throws InterruptedException {

        System.out.println("someMethod ...");

        synchronized (mutex) {
            callObject();
            while(this.receivedObject == null){
                mutex.wait();
            }
        }

        System.out.println("someMethod done.");
        return this.receivedObject;
    }

}

someMethod 等到 receivedObject 存在。 receiveObject 到达时通知。

Answer 2

您需要回电：

private abstract class Callback<T>{
    run(T object);
}


public Object someMethod() {
    callObject(new Callback<Object>()
    {
        @Override
        public void run(Object object)
        {
             System.out.println("The object is" + object + ", wooh!");
        }
    })

}

public void callObject(Callback<Object> callback) {
    // Sends request for the object
    callback.run(object);
}

Answer 3

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class ThreadExample implements Callable<String>{

    @Override
    public String call() throws Exception {
        // TODO Auto-generated method stub
        return "Ashish";
    }

}
public class FutureThreadExample {

    public static void main(String a[]) throws InterruptedException, ExecutionException {
        ExecutorService executorService=Executors.newFixedThreadPool(1);
        List <Future<String>>objList=new ArrayList<Future<String>>();
       for(int i=0;i<10;i++) {
            Future<String> obj=executorService.submit(new ThreadExample());
            objList.add(obj);
       }
        for( Future<String> fut:objList) {
            System.out.println(fut.get());
        }
        executorService.shutdown();
    }


}

将来有结果？

Getting a result in the future?

java

asynchronous

callable

futuretask

runnable