public  void destroy() 
{

}

 protected String doIntercept(ActionInvocation actionInvocation) throws Exception 
{
        ActionProxy proxy = actionInvocation.getProxy();
        String name = getBackgroundProcessName(proxy);
        ActionContext context = actionInvocation.getInvocationContext();
        Map session = context.getSession();
        HttpSession httpSession = ServletActionContext.getRequest().getSession(true);
        Boolean secondTime  = true;
        if (executeAfterValidationPass) {
            secondTime = (Boolean) context.get(KEY);
            if (secondTime == null) {
                context.put(KEY, true);
                secondTime = false;
            } else {
                secondTime = true;
                context.put(KEY, null);
            }
        }
        //sync on the real HttpSession as the session from the context is a wrap that is created
        //on every request
        synchronized (httpSession) {
            BackgroundProcess bp = (BackgroundProcess) session.get(KEY + name);
            if ((!executeAfterValidationPass || secondTime) && bp == null) {
                bp = getNewBackgroundProcess(name, actionInvocation, threadPriority);
                session.put(KEY + name, bp);
                performInitialDelay(bp); // first time let some time pass before showing wait page
                secondTime = false;
            }
            if ((!executeAfterValidationPass || !secondTime) && bp != null && !bp.isDone()) {
                actionInvocation.getStack().push(bp.getAction());
                if (TokenHelper.getToken() != null) {
                    session.put(TokenHelper.getTokenName(), TokenHelper.getToken());
                }
                Map results = proxy.getConfig().getResults();
                if (!results.containsKey(WAIT)) {
                    LOG.warn("ExecuteAndWait interceptor has detected that no result named 'wait' is available. " +
                            "Defaulting to a plain built-in wait page. It is highly recommend you " +
                            "provide an action-specific or global result named '" + WAIT +
                            "'.");
                    // no wait result? hmm -- let's try to do dynamically put it in for you!
                    //we used to add a fake "wait" result here, since the configuration is unmodifiable, that is no longer
                    //an option, see WW-3068
                    FreemarkerResult waitResult = new FreemarkerResult();
                    container.inject(waitResult);
                    waitResult.setLocation("/org/apache/struts2/interceptor/wait.ftl");
                    waitResult.execute(actionInvocation);
                    return Action.NONE;
                }
                return WAIT;
            } else if ((!executeAfterValidationPass || !secondTime) && bp != null && bp.isDone()) {
                session.remove(KEY + name);
                actionInvocation.getStack().push(bp.getAction());
                // if an exception occured during action execution, throw it here
                if (bp.getException() != null) {
                    throw bp.getException();
                }
                return bp.getResult();
            } else {
                // this is the first instance of the interceptor and there is no existing action
                // already run in the background, so let's just let this pass through. We assume
                // the action invocation will be run in the background on the subsequent pass through
                // this interceptor
                return actionInvocation.invoke();
            }
        }
}

 protected String getBackgroundProcessName(ActionProxy proxy) 
{
        return proxy.getActionName();
}

Returns the name to associate the background process. Override to change the way background processes are mapped to requests.

 protected BackgroundProcess getNewBackgroundProcess(String name,
    ActionInvocation actionInvocation,
    int threadPriority) 
{
        return new BackgroundProcess(name + "BackgroundThread", actionInvocation, threadPriority);
}

Creates a new background process

 public  void init() 
{

}

 protected  void performInitialDelay(BackgroundProcess bp) throws InterruptedException 
{
        if (delay < = 0 || delaySleepInterval < = 0) {
            return;
        }
        int steps = delay / delaySleepInterval;
        if (LOG.isDebugEnabled()) {
            LOG.debug("Delaying for " + delay + " millis. (using " + steps + " steps)");
        }
        int step;
        for (step = 0; step <  steps && !bp.isDone(); step++) {
            Thread.sleep(delaySleepInterval);
        }
        if (LOG.isDebugEnabled()) {
            LOG.debug("Sleeping ended after " + step + " steps and the background process is " + (bp.isDone() ? " done" : " not done"));
        }
}

Performs the initial delay.

When this interceptor is executed for the first time this methods handles any provided initial delay. An initial delay is a time in miliseconds we let the server wait before we continue.
During the wait this interceptor will wake every 100 millis to check if the background process is done premature, thus if the job for some reason doesn't take to long the wait page is not shown to the user.

 public  void setContainer(Container container) 
{
        this.container = container;
}

 public  void setDelay(int delay) 
{
        this.delay = delay;
}

Sets the initial delay in millis (msec).

 public  void setDelaySleepInterval(int delaySleepInterval) 
{
        this.delaySleepInterval = delaySleepInterval;
}

Sets the sleep interval in millis (msec) when performing the initial delay.

 public  void setExecuteAfterValidationPass(boolean executeAfterValidationPass) 
{
        this.executeAfterValidationPass = executeAfterValidationPass;
}

Whether to start the background process after the second pass (first being validation) or not

 public  void setThreadPriority(int threadPriority) 
{
        this.threadPriority = threadPriority;
}

Sets the thread priority of the background process.