Multithreading and Thead pools- Need Design suggestion

I want to implement something like this.

1.A background process which will be running forever

2.The background process will check the database for any requests in pending state. If any found,will assign a separate thread to process the request.So one thread per request.Max threads at any point of time should be 10. Once the thread has finished execution,the status of the request will be updated to something,say "completed".

My code outline looks something like this.

public class SimpleDaemon {
private static final int MAXTHREADS = 10;

public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(MAXTHREADS);
    RequestService requestService = null; //init code omitted
    while(true){
        List<Request> pending = requestService.findPendingRequests();
        List<Future<MyAppResponse>> completed = new ArrayList<Future<MyAppResponse>>(pending.size());
        for (Request req:pending) {
            Callable<MyAppResponse> worker = new MyCallable(req);
            Future<MyAppResponse> submit = executor.submit(worker);
            completed.add(submit);
        }

        // Now retrieve the result
        for (Future<MyAppResponse> future : completed) {
            try {
                re开发者_如何学JAVAquestService.updateStatus(future.getRequestId());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(10000); // Sleep sometime
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
 }

Can anyone spend sometime to review this and comment any suggestion/optimization (from multi threading perspective) ? Thanks.

Using a max threads of ten seems somewhat arbitrary. Is this the maximum available connections to your database?

I'm a little confused as to why you are purposefully introducing latency into your applications. Why aren't pending requests submitted to the Executor immediately?
The task submitted to the Executor could then update the RequestService, or you could have a separate worker Thread belonging to the RequestService which calls poll on a BlockingQueue of Future<MyAppResponse>.

You have no shutdown/termination strategy. Nothing indicates that main is run on a Thread that is set to Daemon. If it is, I think the ExecutorService's worker threads will inherit the daemon status, but then your application could shutdown with live connection to the database, no? Isn't that bad?
If the thread isn't really a Daemon, then you need to handle that InterruptedException and treat it as an indication that you are being asked to exit the application.

Your calls to requestService appear to be single threaded resulted in any long running queries preventing completed queries from being completed.

Unless the updateStatus has to be called in a specific order, I suggest you call this as part of your query in MyCallable. This could simplify your code and allow results to be processed as they become available.

You need to handle the potential throwing of a RejectedExecutionException by executor.submit() because the thread-pool has a finite number of threads.

You'd probably be better off using an ExecutorCompletionService rather than an ExecutorService because the former can tell you when a task completes.

I strongly recommend reading Brian Goetz's book "Java Concurrency in Practice".