CODEWITHSUNDEEP
javamultithreadingrestjerseyjax-rs
cmd
cmd

Reputation: 11841

REST with JAX-RS - Handling long running operations

I have a REST service implemented with JAX-RS. Some of the operations take a long time to complete, potentially 15-30 minutes. For these cases, my inclination is to dispatch a background thread to process the long running operation and then respond immediately with HTTP status 202 ACCEPTED. The response would contain a location header with a url that clients can use to poll for progress.

This approach requires the creation of threads to handle long running operations, such that 202 ACCEPTED can be returned immediately. I also know that that creating your own threads in a Java EE container is generally bad practice!

My questions are as follows:

  1. Do folks agree that this is a correct approach?
  2. Assuming it is correct, Can folks recommend a 'good practice' solution that enables me to dispatch a long running operation in the background and return immediately?

Also, to avoid managing my own threads, I looked into the JAX-RS asynchronous server api. Unfortunately, although this improves server throughput, it will not allow me to respond immediately with ACCEPTED.

Jersey states the following:

Note that the use of server-side asynchronous processing model will not improve the 
request processing time perceived by the client. It will however increase the
throughput of the server, by releasing the initial request processing thread back to
the I/O container while the request may still be waiting in a queue for processing or    
the processing may still be running on another dedicated thread. The released I/O  
container thread can be used to accept and process new incoming request connections.

Any help is appreciated. Thanks!

Upvotes: 15

Views: 10085

Answers (3)

Wojciech Owczarczyk
Wojciech Owczarczyk

Reputation: 5745

I think that Jersey Async docs exhaust the topic quite well. Here is a brief snippet:

@Path("/async/longRunning")
public class MyResource {

   @GET
   public void longRunningOp(@Suspended final AsyncResponse ar) {
       executor.submit(
            new Runnable() {
                public void run() {
                    executeLongRunningOp();
                    ar.resume("Hello async world!");
                } });
  }
}

When it comes to the following quotation from the docs:

Note that the use of server-side asynchronous processing model will not improve the request processing time perceived by the client.(...)

I thing you have misunderstood it a bit. What the author of the docs tried to express here is that asynchroneous processing will not speed up things just by itself. But the response can be returned immediately using for instance the following:

return Response.status(Status.ACCEPTED).build();

Upvotes: 2

Justinas Jakavonis
Justinas Jakavonis

Reputation: 8848

I would make a method which immediately returns response with process id and time when it will be completed. A calculation starts in background and it is cached for some time after completion. Then client tries to retrieve information with specific id and gets related response.

Upvotes: 0

Sotirios Delimanolis
Sotirios Delimanolis

Reputation: 280174

I also know that that creating your own threads in a Java EE container is generally bad practice!

Although the above is true in most cases, in this one you don't have a choice. At least don't create your Thread instances yourself. Let an ExecutorService do it for you. If anything, make this ExecutorService have a big enough pool and share it with all your components.

Upvotes: 5

Related Questions