Implementieren Sie eine ExecutorService zur Ausführung von batches von Aufgaben

Ich bin auf der Suche nach einer Möglichkeit zur Ausführung von batches von Aufgaben in java. Die Idee ist, eine ExecutorService basiert auf einem thread-pool, der wird mir erlauben, zu verbreiten, eine Reihe von Callable zwischen verschiedenen threads von einem main thread. Diese Klasse sollte eine "waitForCompletion" Methode, die die main thread schlafen, bis alle Aufgaben ausgeführt werden. Dann die main thread soll geweckt werden, und es werden einige Operationen durchzuführen und erneut eine Reihe von Aufgaben.

Dieser Prozess wird mehrmals wiederholt, so möchte ich ExecutorService.shutdown wie dies erforderlich wäre, um mehrere Instanzen von ExecutorService.

Derzeit habe ich umgesetzt es in der folgenden Weise mit einer AtomicInteger, und ein Lock/Condition:

public class BatchThreadPoolExecutor extends ThreadPoolExecutor {
  private final AtomicInteger mActiveCount;
  private final Lock          mLock;
  private final Condition     mCondition;

  public <C extends Callable<V>, V> Map<C, Future<V>> submitBatch(Collection<C> batch){
    ...
    for(C task : batch){
      submit(task);
      mActiveCount.incrementAndGet();
    }
  }

  @Override
  protected void afterExecute(Runnable r, Throwable t) {
    super.afterExecute(r, t);
    mLock.lock();
    if (mActiveCount.decrementAndGet() == 0) {
      mCondition.signalAll();
    }
    mLock.unlock();
  }

  public void awaitBatchCompletion() throws InterruptedException {
    ...
    //Lock and wait until there is no active task
    mLock.lock();
    while (mActiveCount.get() > 0) {
      try {
        mCondition.await();
      } catch (InterruptedException e) {
        mLock.unlock();
        throw e;
      }
    }
    mLock.unlock();
  } 
}

Bitte nicht, dass ich nicht unbedingt Einreichen, alle Aufgaben aus dem Stapel auf einmal, daher CountDownLatch scheint nicht eine option sein.

Ist dies ein Gültiger Weg, es zu tun? Gibt es eine effizientere/elegante Art und Weise zu implementieren, dass?

Dank