Java parallel db calls

You can use the new Java 8 CompletableFuture. It allows to use asynchronously existing synchronous method.

Say you have a list of requests in the form List<DBRequest> listRequest that you want to run in parallel. You can make a stream and launching all requests asynchronously in the following way.

List<CompletableFuture<DBResult>> listFutureResult =
                     listRequest.stream()
                                .map(req -> CompletableFuture.supplyAsync(
                                              () -> dbLaunchRequest(req), executor))
                                .collect(Collectors.toList());    
List<DBResult> listResult = 
                     listFutureResult.stream()
                                     .map(CompletableFuture::join)
                                     .collect(Collectors.toList());

To be effective you have to write your own custom Executor

private final Executor executor = 
    Executors.newFixedThreadPool(Math.min(listRequest.size(), 100),
                                 new ThreadFactory(){
               public Thread newThread(Runnable r){
                    Thread t = new Thread(r);
                    t.setDaemon(true);
                    return t;
               }
});

Like this you can have enough threads but not too much. Marking threads to deamons allows you to finish the program even if one thread is blocked.

You can find clear explanations about these techniques in the chapter 11 of the book Java 8 in action

== UPDATE for Java 7 ==

If you are stick with Java 7, you can use the following solution:

class DBResult{}
class DBRequest implements Callable<DBResult>{
    @Override
    public DBResult call(){return new DBResult();}
}
class AsyncTest{
   public void test(){
     try {
         for(Future<DBResult> futureResult : ((ExecutorService)executor).invokeAll(listRequest)){
             futureResult.get();
         }
     } catch (InterruptedException | ExecutionException ex) {
         Logger.getLogger(SoTest.class.getName()).log(Level.SEVERE, null, ex);
     }
   }
}

All requests are run asynchronously and you then wait for their completion, in the order of the list.

Finally, to answer the subsidiary question in the comment, you don't have to create a thread pool for each request.