我如何判断ThreadPool的任务何时完成

在c++11中，我有一个ThreadPool对象，它管理通过单个lambda函数排队的多个线程。我知道我必须处理多少行数据，所以我提前知道我需要对N个作业进行排队。我不确定的是如何判断所有这些工作何时完成，这样我就可以继续下一步了。

这是管理线程池的代码：

#include <cstdlib>
#include <vector>
#include <deque>
#include <iostream>
#include <atomic>
#include <thread>
#include <mutex>
#include <condition_variable>
class ThreadPool;
class Worker {
public:
    Worker(ThreadPool &s) : pool(s) { }
    void operator()();
private:
    ThreadPool &pool;
};
class ThreadPool {
public:
    ThreadPool(size_t);
    template<class F>
    void enqueue(F f);
    ~ThreadPool();
    void joinAll();
    int taskSize();
private:
    friend class Worker;
    // the task queue
    std::deque< std::function<void()> > tasks;
    // keep track of threads
    std::vector< std::thread > workers;
    // sync
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};
void Worker::operator()()
{
    std::function<void()> task;
    while(true)
    {
        {   // acquire lock
            std::unique_lock<std::mutex> 
                lock(pool.queue_mutex);
            // look for a work item
            while ( !pool.stop && pool.tasks.empty() ) {
                // if there are none wait for notification
                pool.condition.wait(lock);
            }
            if ( pool.stop )  {// exit if the pool is stopped
                return;
            }
            // get the task from the queue
            task = pool.tasks.front();
            pool.tasks.pop_front();
        }   // release lock
        // execute the task
        task();
    }
}

// the constructor just launches some amount of workers
ThreadPool::ThreadPool(size_t threads)
    :   stop(false)
{
    for (size_t i = 0;i<threads;++i) {
        workers.push_back(std::thread(Worker(*this)));
    }
    //workers.
    //tasks.
}
// the destructor joins all threads
ThreadPool::~ThreadPool()
{
    // stop all threads
    stop = true;
    condition.notify_all();
    // join them
    for ( size_t i = 0;i<workers.size();++i) {
        workers[i].join();
    }
}
void ThreadPool::joinAll() {
    // join them
    for ( size_t i = 0;i<workers.size();++i) {
        workers[i].join();
    }
}
int ThreadPool::taskSize() {
    return tasks.size();
}
// add new work item to the pool
template<class F>
void ThreadPool::enqueue(F f)
{
    { // acquire lock
        std::unique_lock<std::mutex> lock(queue_mutex);
        // add the task
        tasks.push_back(std::function<void()>(f));
    } // release lock
    // wake up one thread
    condition.notify_one();
}

然后我把我的工作分配到这样的线程中：

ThreadPool pool(4);
/* ... */
for (int y=0;y<N;y++) {
    pool->enqueue([this,y] {
        this->ProcessRow(y);
    });
}
// wait until all threads are finished
std::this_thread::sleep_for( std::chrono::milliseconds(100) );

等待100毫秒是有效的，因为我知道这些工作可以在不到100毫秒的时间内完成，但显然这不是最好的方法。一旦它完成了N行处理，就需要再经历1000代左右的相同处理。显然，我想尽快开始下一代。

我知道一定有办法把代码添加到我的线程池中，这样我就可以做这样的事情：

while ( pool->isBusy() ) {
    std::this_thread::sleep_for( std::chrono::milliseconds(1) );
}

我已经为此工作了几个晚上，我发现很难找到如何做到这一点的好例子那么，实现我的isBusy（）方法的正确方法是什么