Waiting on unknown threads to finish

Question

I have made the ExecutionService class, and now i have a small problem. The point of the class was to split the job normally done by one thread into as many as possible. Now, i need the thread that called executeInstantly/waitToExecute to wait until the requested task(s) are done, and there are no more tasks to process. What would be the best way to implement that? Note, only one thread will be adding to the Queue of tasks, and its the same one that needs to wait on them to finish.
package jad.util;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ExecutionService {
    public ExecutionService() {
        runnableTasks = new LinkedBlockingQueue<Runnable>(Integer.MAX_VALUE);
        initializeExecutors(Runtime.getRuntime().availableProcessors());
    public ExecutionService(BlockingQueue<Runnable> blockingQueue) {
        runnableTasks = blockingQueue;
        initializeExecutors(Runtime.getRuntime().availableProcessors());
    public ExecutionService(final int NUM_THREADS, final int MAX_JOBS) {
        runnableTasks = new LinkedBlockingQueue<Runnable>(MAX_JOBS);
        initializeExecutors(NUM_THREADS);
    private final void initializeExecutors(final int NUM_THREADS) {
        for (int i = 0; i < NUM_THREADS; i++) {
            createNewExecutor();
            ++numThreadsRunning;
    private final Runnable getPermTask() {
        return new Runnable() {
            @Override
            public void run() {
                Exception ex = null;
                try {
                    while (continueRunning) {
                        getNewTask().run();
                } catch (InterruptedException e) {
                    (ex = e).printStackTrace();
                } catch (Exception e) {
                    (ex = e).printStackTrace();
                } finally {
                    if (ex != null) {
                        createNewExecutor();
    private Executor createNewExecutor() {
        return new Executor(getPermTask());
    private Runnable getNewTask() throws InterruptedException {
        return runnableTasks.take();
    public boolean executeImmediately(Runnable task) throws Exception {
        if (!continueRunning) {
            throw new Exception("ExecutorService instance is shut down");
        return runnableTasks.offer(task);
    public void waitToExecute(Runnable task) throws InterruptedException, Exception {
        if (!continueRunning) {
            throw new Exception("ExecutorService instance is shut down");
        runnableTasks.put(task);
    public void shutDown() {
        continueRunning = false;
        Runnable emptyTask = new Runnable() {
            @Override
            public void run() {
                return;
        for (int i = 0; i < numThreadsRunning; i++) {
            try {
                waitToExecute(emptyTask);
            } catch (InterruptedException e) {
                System.out.println("Could not shut down!");
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
    private int numThreadsRunning = 0;
    private volatile boolean continueRunning = true;
    private BlockingQueue<Runnable> runnableTasks;
class Executor {
    public Executor(Runnable task) {
        Thread t = new Thread(task);
        t.setDaemon(true);
        t.setName("Executor service thread");
        t.start();
}Edited by: Jadz_Core on Aug 6, 2009 9:36 PM

Answer 1

You would use a java.util.CountDownLatch if you only wanted to wait for the tasks currently executing and waiting in the queue (for example, there would be no tasks added AFTER the waiting began). I think this is suitable for your situation since you said there would be just one thread adding to the queue.
Pseudocode:
class ExecutorService {
    private volatile CountDownLatch counter = new CountDownLatch(Integer.MAX_VALUE);  //start countdown latch at really high values
    private AtomicInteger activeThreadCount = new AtomicInteger(0); //keep track of threads actually working
    private BlockingQueue queue; //keep waiting tasks
    class PermTask implements Runnable
        public void run()
            while (!shutdown)
                Runnable task = queue.take();
                activeThreadCount.incrementAndGet();
                try
                    taskToRun.run();
                finally
                    activeThreadCount.decrementAndGet();
                    counter.countDown();
    public void waitForTasksToComplete()
        int totalTasks = queue.size() + activeThreadCount.get();
        counter = new CountDownLatch(totalTasks);
        counter.await();
    }This would take a bit of cleaning up, for instance you have to protect the activeThreadCount and the counter so that the values don't change in the middle of some work (a ReadWriteReentrantLock might work nicely here - the PermTask would acquire Read Locks so they don't block each other. The wait... method acquires a Write lock to it waits for Reads to finish, and blocks more Reads until it is done). But it should get you started.
Edited by: stevejluke on Aug 7, 2009 7:01 AM