Question

Following code create that Annotation.

As described here,
http://engineering.webengage.com/2012/03/12/a-peek-into-webengages-security-layer-super-cool-use-of-java-annotations

/**
 * Defining the Asynch interface
 */
@Retention(RetentionPolicy.RUNTIME)
public @interface Asynch {}

/**
 * Implementation of the Asynch interface. Every method in our controllers
 * goes through this interceptor. If the Asynch annotation is present,
 * this implementation invokes a new Thread to execute the method. Simple!
 */
public class AsynchInterceptor implements MethodInterceptor {
  public Object invoke(final MethodInvocation invocation) throws Throwable {
    Method method = invocation.getMethod();
    Annotation[] declaredAnnotations = method.getDeclaredAnnotations(); 
    if(declaredAnnotations != null && declaredAnnotations.length > 0) {
      for (Annotation annotation : declaredAnnotations) {
        if(annotation instanceof Asynch) {
          //start the requested task in a new thread and immediately
          //return back control to the caller
          new Thread(invocation.getMethod().getName()) {
            public void execute() {
              invocation.proceed();
            }
          }.start();
          return null;
        }
      }
    }
    return invocation.proceed();
  }
}

And it is used with method calls that returns nothing ( void ).

Example,

/**
 * So, earlier we had a simple method in our interface which we later
 * annotated with the Asynch @interface. Bang! The caller doesn't need
 * to worry about it now. This method (no matter who the caller is)
 * gets executed asynchronously. Ain't that awesome? 
 */
@Asynch
public void refreshSurveyStatusOnResponse(String licenseCode, Integer surveyId);

What are the pros and cons ? What if we used a message queue and worker thread pool to solve instead of asynchronous method call ?
What solution could have been used from standard java instead of such homegrown solution?
Above method seems to have one backlog that Asynch method calls do not return any value in such a case above code will break. ,Is it logical to expect a return value on asynchronous method call ?

Answer 1

What are the pros and cons ?

You should be able to work out the pros. If you can’t think of any; you have a solution looking for a problem to solve. Usually the idea is to improve the performance of the thread which is not waiting for the result of the call.

Cons, if you are not careful it could be slower instead of faster. Depends on the voerhead vs the time saved.

What if we used a message queue and worker thread pool to solve instead of asynchronous method call ?

The only way to know is to try it.

What solution could have been used from standard Java instead of such homegrown solution?

You can use an ExecutoreService which returns a Future object. You can get the result or exception with get()

Above method seems to have one backlog that Asynch method calls do not return any value in such a case above code will break. ,Is it logical to expect a return value on asynchronous method call ?

ExecutorServices return a Future which can have a return value or the Exception/Throwable which is a thrown (another possible result 😉