Java / Guava中的异步编程

Question

class A{
    final B; 

    B.compute(); // Does executing this line create a new thread since this returns
    // a future and the entire function is executed by the same thread ?


    }

    class B{

    Future<Void> compute(){

    C obj = factoryOfC.getC();

    ListenableFuture<Void> future = executorService.submit (new Callable(){
        doSomething();
    });

    Futures.addCallback(future, new FutureCallback<Void>(){
        @Override
        void onSuccess(){
        }
        @Override
        void onFailure(){
        }

    } // end of callback. 
} // end of class B

How would you define a unit of work here ? Which thread/s will be doing which unit of work ? Would the callable and callback be executed in the same thread ?

WILL obj of type C be executed by the same thread ?

Answer 1

Have you run it to see what it does? I doubt it because what you've provided won't compile.

Have you read the JavaDoc for the methods you are calling? The answers are there.

You submit a Callable to ExecutorService.submit() . The documentation for Executor says:

The command may execute in a new thread, in a pooled thread, or in the calling thread, at the discretion of the Executor implementation

... and the documentation for ExecutorService adds no specifics; meaning that as a programmer all you know is that you've requested that this be run in some thread, some time in future.

But you have a Future object that acts as a handle on the promised execution of your task. You use Futures.addCallback() to request that some work is performed when the task completes. In what thread will this work run?

The JavaDoc for Futures.addCallback() says:

• If the input Future is done at the time addCallback is called, addCallback will execute the callback inline.
• If the input Future is not yet done, addCallback will schedule the callback to be run by the thread that completes the input Future, which may be an internal system thread such as an RPC network thread.

Answer 2

Not the execution of the line B.compute(); alone creates a new thread; the line executorService.submit submits a new Callable to the ExecutorService which runs in a new thread.