Index: src/java/org/apache/lucene/search/ParallelMultiSearcher.java
===================================================================
--- src/java/org/apache/lucene/search/ParallelMultiSearcher.java	(revision 952449)
+++ src/java/org/apache/lucene/search/ParallelMultiSearcher.java	(working copy)
@@ -21,10 +21,11 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Set;
 import java.util.concurrent.Callable;
+import java.util.concurrent.CompletionService;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorCompletionService;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
@@ -67,17 +68,17 @@
    */
   @Override
   public int docFreq(final Term term) throws IOException {
-    @SuppressWarnings("unchecked") final Future<Integer>[] searchThreads = new Future[searchables.length];
-    for (int i = 0; i < searchables.length; i++) { // search each searchable
+    final CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(this.executor);
+    for(int i = 0; i < searchables.length; i++) {
       final Searchable searchable = searchables[i];
-      searchThreads[i] = executor.submit(new Callable<Integer>() {
+      completionService.submit(new Callable<Integer>() {
         public Integer call() throws IOException {
           return Integer.valueOf(searchable.docFreq(term));
         }
       });
     }
     final CountDocFreq func = new CountDocFreq();
-    foreach(func, Arrays.asList(searchThreads));
+    foreach(func, completionService, searchables.length);
     return func.docFreq;
   }
 
@@ -90,14 +91,15 @@
   public TopDocs search(Weight weight, Filter filter, int nDocs) throws IOException {
     final HitQueue hq = new HitQueue(nDocs, false);
     final Lock lock = new ReentrantLock();
-    @SuppressWarnings("unchecked") final Future<TopDocs>[] searchThreads = new Future[searchables.length];
+    final CompletionService<TopDocs> completionService = new ExecutorCompletionService<TopDocs>(this.executor);
+    
     for (int i = 0; i < searchables.length; i++) { // search each searchable
-      searchThreads[i] = executor.submit(
+      completionService.submit(
           new MultiSearcherCallableNoSort(lock, searchables[i], weight, filter, nDocs, hq, i, starts));
     }
 
     final CountTotalHits<TopDocs> func = new CountTotalHits<TopDocs>();
-    foreach(func, Arrays.asList(searchThreads));
+    foreach(func, completionService, searchables.length);
 
     final ScoreDoc[] scoreDocs = new ScoreDoc[hq.size()];
     for (int i = hq.size() - 1; i >= 0; i--) // put docs in array
@@ -117,14 +119,14 @@
 
     final FieldDocSortedHitQueue hq = new FieldDocSortedHitQueue(nDocs);
     final Lock lock = new ReentrantLock();
-    @SuppressWarnings("unchecked") final Future<TopFieldDocs>[] searchThreads = new Future[searchables.length];
+    final CompletionService<TopFieldDocs> completionService = new ExecutorCompletionService<TopFieldDocs>(this.executor);
     for (int i = 0; i < searchables.length; i++) { // search each searchable
-      searchThreads[i] = executor.submit(
+      completionService.submit(
           new MultiSearcherCallableWithSort(lock, searchables[i], weight, filter, nDocs, hq, sort, i, starts));
     }
 
     final CountTotalHits<TopFieldDocs> func = new CountTotalHits<TopFieldDocs>();
-    foreach(func, Arrays.asList(searchThreads));
+    foreach(func, completionService, searchables.length);
 
     final ScoreDoc[] scoreDocs = new ScoreDoc[hq.size()];
     for (int i = hq.size() - 1; i >= 0; i--) // put docs in array
@@ -192,13 +194,12 @@
   HashMap<Term, Integer> createDocFrequencyMap(Set<Term> terms) throws IOException {
     final Term[] allTermsArray = terms.toArray(new Term[terms.size()]);
     final int[] aggregatedDocFreqs = new int[terms.size()];
-    final ArrayList<Future<int[]>> searchThreads = new ArrayList<Future<int[]>>(searchables.length);
+    final CompletionService<int[]> completionService = new ExecutorCompletionService<int[]>(this.executor);
     for (Searchable searchable : searchables) {
-      final Future<int[]> future = executor.submit(
+      completionService.submit(
           new DocumentFrequencyCallable(searchable, allTermsArray));
-      searchThreads.add(future);
     }
-    foreach(new AggregateDocFrequency(aggregatedDocFreqs), searchThreads);
+    foreach(new AggregateDocFrequency(aggregatedDocFreqs), completionService, searchables.length);
 
     final HashMap<Term,Integer> dfMap = new HashMap<Term,Integer>();
     for(int i=0; i<allTermsArray.length; i++) {
@@ -211,10 +212,10 @@
    * apply the function to each element of the list. This method encapsulates the logic how 
    * to wait for concurrently executed searchables.  
    */
-  private <T> void foreach(Function<T> func, List<Future<T>> list) throws IOException{
-    for (Future<T> future : list) {
+  private <T> void foreach(Function<T> func, CompletionService<T> service, int numTasks) throws IOException {
+    for(int i = 0; i < numTasks; i++) {
       try{
-        func.apply(future.get());
+        func.apply(service.take().get());
       } catch (ExecutionException e) {
         final Throwable throwable = e.getCause();
         if (throwable instanceof IOException)
@@ -225,7 +226,7 @@
       }
     }
   }
-
+  
   // Both functions could be reduced to Int as other values of TopDocs
   // are not needed. Using sep. functions is more self documenting.
   /**