Getting a result in the future?

Question

I'm looking to get a result from a method which can take a while to complete and doesn't actually return the object, so I'd like to deal with it as effectively as possible. Here's an example of what I'm trying to achieve:

    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?
    }

The method callObject will call to get the object, however a different method is called with the object in. I want someMethod() to be able to call for the object, and then return what it eventually receives, even though the actual call and receive are separate methods.

I've looked into using FutureTasks and Callables which I think is the way forward, I'm just not too sure how to implement it.

Sorry if I didn't explain myself too well, I'll give more information if necessary.

Thanks!

Solution

You could write a method, that kicks of some long running task asynchronously. You would then return a future object, that is empty but gets filled when the long running task is completed. In other programming languages, this is called a promise.

Here is an simple example. I created a method called someLongAsyncOperation which executes something that takes a while. To simulate this, I just sleep for 3 seconds before generating an answer.

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

If you execute this little test class, you'll see, that someLongAsyncOperation returns fast, but when calling future.get(); we wait for the operation to complete.

You could now do something like starting of more than one longAsyncOperation, so they would run in parallel. And then wait until all of them are done.

Does this work as a starting point for you?

EDIT

You could implement someMethod like this:

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

Which will make the async operation synchron again, by calling it and waiting for the result.

EDIT2

Here's another example that uses 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 waits until receivedObject exists. receiveObject notifies upon arrival.

Comments

[Anonomoose]

Looks promising, where would the receiving of the object come into that though?

[yedidyak]

You get it in the callback, you can call it from there instead of the System.out. Of course, you need to make sure that the callback is executed on a back thread, and the callback is executed on the main thread. But that depends on what threading system you want to use.

[Anonomoose]

Okay, but by making a reference to the result, how does it know that the result has been received?

[yedidyak]

You only call the callback when it has been. Then the callback takes it as a parameter.

[Anonomoose]

I see, and which method calls the callback?

[yedidyak]

In the example code I wrote, callObject calls it. But it should be wrapped to run on the main thread, after callObject is run on a back thread to make it asynchronous.

[Anonomoose]

Okay, so how would I go about creating/storing that callback used in callObject() so that it can be ran when the object's received?

[yedidyak]

You pass it as a parameter, like in the example I gave.

[Anonomoose]

But where is that Callback created in the first place for it then to be referenced?

[yedidyak]

In someMethod, as an anonymous inner class.

[Anonomoose]

Gotcha, going back to my original question though - I can't see where the method called when the object is received comes into this?

[yedidyak]

Instead of the line 'System.out.println("The object is" + object + ", wooh!");', put 'receiveObject(object);'

[Brian Tompsett - 汤莱恩]

While this code snippet may solve the problem, it doesn't explain why or how it answers the question. Please include an explanation for your code, as that really helps to improve the quality of your post. Remember that you are answering the question for readers in the future, and those people might not know the reasons for your code suggestion. You can use the edit button to improve this answer to get more votes and reputation!