Is there any way to know the progress of a EJB Asynchronous process?

I'm trying to get the percentage of the progress from a EJB Asynchronous process. Is thi开发者_如何学Cs possible?

Does anyone have an idea how I could do this?

---

To get to know the progress of asynchronous processes is always tricky, especially if you don't know if they have actually started yet.

The best way I have found is to write another function that just gets the progress, so, if you have some unique id for each call, then update a hashmap with the current process. You may want to look at Concurrent Hashmap (http://download-llnw.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/ConcurrentHashMap.html)

Then this other lookup function will just take the unique id, and return the progress back to the client.

If it hasn't been started, you can also return that, and ideally you may want to also be able to return any error messages that came up in the processing.

Then, when it has finished, and you returned the error message or success, then delete it from the hashmap, the client got the information, and that info won't change, so no point it keeping it around.

UPDATE:

In your interface make a new function

String progressDone(String id);

You will then refer to that synchronously, as it just goes out and comes right back, so it can look up the id in the hashmap and return either the percentage done or an error message.

But, this means that your actually worker function needs to every so often put information in the hashmap as to where it is, which is why I suggested using the concurrent hashmap, so that you don't have to worry about concurrent writes, and so locking considerations.

---

The solution I have found is an context object shared between asynchronous method and main thread. Here is an example:

Asynchronous job itself:

@Stateless
public class AsyncRunner implements AsyncRunnerLocal {
    @Asynchronous
    public Future<ResultObject> doWorkAsynchronous(WorkContext context) {
        context.setRunning(true);
        for (int i = 0; i < 100; i++) {
            //Do the next iteration of your work here
            context.setProgress(i);
        }
        context.setRunning(false);
        return new AsyncResult(new ResultObject());
    }
}

Shared context object. Important thing here is volatile keyword. Field values will be locally cached in each thread without it and progress will not be visible in main thread:

public class WorkContext {
    //volatile is important!
    private volatile Integer progress = 0;
    private volatile boolean running = false;
    //getters and setters are omitted
}

Usage example:

public class ProgressChecker {
    @EJB
    private AsyncRunnerLocal asyncRunner;

    private WorkContext context;
    private Future<ResultObject> future;

    public void startJob() {
        this.context = new WorkContext();
        future = asyncRunner.doWorkAsynchronous(this.context);
        //the job is running now
        while (!future.isDone()) {
            System.out.println("Progress: " + this.context.getProgress());
            Thread.sleep(1000); //try catch is omitted
        }
    }
}

---

In EJB3.1 @Asynchronous method-calls can return java.util.concurrent.Future, this interface provides information boolean isCancelled() or boolean isDone(), but no information if the execution started. From my point of view, there is no way to get the information if the process started its execution via the EJB-Container in standard ways.