I am trying to implement an "@Asynchronous" interceptor that runs methods annotated with the @Asynchronous annotation in a separate thread. The implementation of the interceptor currently looks as follows:

private static final ThreadGroup asyncMethods = new ThreadGroup("asynchronous method invocations");

@AroundInvoke
public Object manageAsynchronous(final InvocationContext ctx) throws Exception {

final UUID threadID = UUID.randomUUID();

Runnable r = new Runnable() {
@Override
public void run() {
try {
log.debug("asynchronous method invocation of {}.{} (Thread ID {})",new Object[]

{ctx.getTarget().getClass().getName(),ctx.getMethod().getName(), threadID}

);
Object val = ctx.proceed();

if(val != null) {
log.debug("asynchronous method invocation of {}.{} (Thread ID {}) returned value {}",new Object[]

{ctx.getClass().getName(),ctx.getMethod().getName(), threadID, val}

);
}
} catch(Exception ex)

{ log.error("exception during asynchronous method invocation",ex); }

}
};

Thread t = new Thread(asyncMethods,r);
t.setName("asynchronous method invocation of "ctx.getTarget().getClass().getName()+ctx.getMethod().getName() + " (Threaad ID " + threadID")");
t.start();

return null;
}

Now the problem is that the interceptor is called infinitely often. The reason is that the annotated method forks a new thread and then returns instantly, setting the variable "currentPosition" in SimpleInterceptorChain back to the value 0 (in a "finally" block). So when the proceed() method is called inside the thread, the interceptor chain again points to the first interceptor in the chain and it all repeats infinitely.