What are the ways not to wait for execution of a code block or a method?

Question

What are the correct ways/practice/implementation/strategies (or whatever we call it as) for not to wait for code block/method to finish execution in Java?

Assume the following method:

private void myMethod()
{
     // Some lines of code here
     .....
     .....
     .....

     anotherMethod(); // or this could be a code block

     // Again some lines of code here
     .....
     .....
     .....
}

In this case, I expect myMethod() should not wait for code to finish execution of anotherMethod(). I can also assure here that subsequent lines of code do not depend on anything getting executed within anotherMethod().

Answer 1

You can start it in another Thread if there is no dependency .

new Thread(new Runnable(){

      public void run(){
           anotherMethod();
      }  

}).start();

Answer 2

If you want to invoke the method in the same thread, then the method itself must provide an asynchronous (i.e. non-blocking) implementation. Usually this will involve returning some sort of callback such as a Future, which you can poll/query later to fetch the actual result. An example of this is the ExecutorService.submit() calls - the code you supply will be run, but in a background thread leaving you free to call other methods in the meantime.

I bolded the word invoke before, since fundamentally the only way in Java to have two things happening at once is to use multiple threads. So the method/code block/whatever will have to be executing in a background thread one way or another - usually this is handled for you in an asynchronous method by using some sort of thread pool or whatever is appropriate.

If the method doesn't provide an asynchronous interface, however, the only way to get its logic to run in another thread is to spawn that thread yourself, as org.life.java suggests.

Answer 3

Use

Executor executor = Executors.newSingleThreadExecutor();
executor.execute(new Runnable() {
    @Override
    public void run() {
       anotherMethod();
    }
});
// this is called automatically when the object is gc-ed, 
// but you should not rely on this, hence the explicit call
executor.shutdown();

To quote Effective Java:

Not only should you refrain from writing your own work queues, but you should generally refrain from working directly with threads. The key abstraction is no longer Thread, which served as both the unit of work and the mechanism for executing it. Now the unit of work and mechanism are separate. The key abstraction is the unit of work, which is called a task. There are two kinds of tasks: Runnable and its close cousin, Callable (which is like Runnable, except that it returns a value). The general mechanism for executing tasks is the executor ser- vice. If you think in terms of tasks and let an executor service execute them for you, you gain great flexibility in terms of selecting appropriate execution policies. In essence, the Executor Framework does for execution what the Collections Framework did for aggregation.

Note that you'd better create your executor only once, store it in an instance field and reuse it (and shut it down afterwards)

If you are running in JavaEE 6 or spring, you can annotate your anotherMethod() with @Asynchronous and the container will start a new thread for you.