class CThreadPoolX: public IFinishClientTask
{
...
bool terminated;
...
std::vector<WorkThreadPtr> threads;
std::thread thread;
};

TaskPtr *task = new TaskPtr(new CTaskDer(sec));

TaskPtr task;
task.reset(new CTaskDer(sec));
pool->AddTask(ccc - 48, task);

bool CThreadPool::AddTask(int _clientId, CTask* _task);

this->clientTaskFinisher = clientTaskFinisher;

Я его код не смотрел, но то что ты говоришь — это мелочи все.

К сожалению, в современном С++ я ничего не понимаю. Но, судя по комментариям ...

void CWorkThread::RunTask
    this->task = task; // #1

void CWorkThread::ThreadFunc
        while (!this->task) // #2
              cv.wait(lock);

Two expression evaluations conflict if one of them modifies a memory location (1.7) and the other one accesses or modifies the same memory location.
...
The execution of a program contains a data race if it contains two conflicting actions in different threads, at least one of which is not atomic, and neither happens before the other. Any such data race results in undefined behavior.

int _tmain(int argc, _TCHAR* argv[])
{
    std::unique_ptr<CThreadPoolX> pool (new CThreadPoolX(5));

bool CThreadPool::AddTask(int _clientId, CTask* _task);

void AddTask(int clientID, const TaskPtr task);

std::unique_ptr<CThreadPoolX> pool (new CThreadPoolX(5));

CThreadPoolX pool(5);

Ну и сам факт что они дают задание говорит, что чуваки просто не умеют поговорить нормально на интервью.

package net.sf.brunneng;


import java.util.*;

public class ThreadPool {

   private class ClientTask {
      final int clientId;
      final Runnable runnable;

      public ClientTask(int clientId, Runnable runnable) {
         this.clientId = clientId;
         this.runnable = runnable;
      }
   }

   private boolean closed;
   private final List<ClientTask> tasks = Collections.synchronizedList(new ArrayList<ClientTask>());

   private List<Thread> threads = new ArrayList<Thread>();
   private Set<Integer> executingClients = Collections.synchronizedSet(new HashSet<Integer>());

   public List<ClientTask> getTasks() {
      return tasks;
   }

   public ThreadPool(int threadsCount) {
      for (int i = 0; i < threadsCount; ++i) {
         Thread thread = createThread();
         threads.add(thread);
         thread.start();
      }
   }

   private ClientTask getNextClientTask() {
      ClientTask res = null;
      synchronized (tasks) {
         for (int i = 0; i < tasks.size(); i++) {
            ClientTask task = tasks.get(i);
            if (!executingClients.contains(task.clientId)) {
               res = task;
               executingClients.add(task.clientId);
               tasks.remove(i);
               break;
            }
         }
      }

      return res;
   }

   private Thread createThread() {
      return new Thread(new Runnable() {
         @Override
         public void run() {
            boolean finish = false;

            while (!finish && !closed) {
               try {
                  ClientTask task = getNextClientTask();

                  if (task == null) {
                     synchronized (tasks) {
                        tasks.wait();
                     }
                     continue;
                  }

                  task.runnable.run();
                  executingClients.remove(task.clientId);

               } catch (InterruptedException e) {
                  e.printStackTrace();
                  finish = true;
               }
            }
         }
      });
   }

   public void addTask(int clientId, Runnable task) {
      tasks.add(new ClientTask(clientId, task));

      if (!executingClients.contains(clientId)) {
         synchronized (tasks) {
            tasks.notify();
         }
      }
   }

   public void close() {
      closed = true;

      synchronized (tasks) {
         tasks.notifyAll();
      }

      for (Thread thread : threads) {
         try {
            thread.join();
         } catch (InterruptedException ignored) {

         }
      }
   }
}

package net.sf.brunneng;


import java.util.*;

public class ThreadPool {

   private class ClientTask {
      final int clientId;
      final Runnable runnable;

      public ClientTask(int clientId, Runnable runnable) {
         this.clientId = clientId;
         this.runnable = runnable;
      }
   }

   private boolean closed;
   private final List<ClientTask> tasks = Collections.synchronizedList(new ArrayList<ClientTask>());

   private List<Thread> threads = new ArrayList<Thread>();
   private Set<Integer> executingClients = Collections.synchronizedSet(new HashSet<Integer>());

   public List<ClientTask> getTasks() {
      return tasks;
   }

   public ThreadPool(int threadsCount) {
      for (int i = 0; i < threadsCount; ++i) {
         Thread thread = createThread();
         threads.add(thread);
         thread.start();
      }
   }

   private ClientTask getNextClientTask() {
      ClientTask res = null;
      synchronized (tasks) {
         for (int i = 0; i < tasks.size(); i++) {
            ClientTask task = tasks.get(i);
            if (!executingClients.contains(task.clientId)) {
               res = task;
               executingClients.add(task.clientId);
               tasks.remove(i);
               break;
            }
         }
      }

      return res;
   }

   private Thread createThread() {
      return new Thread(new Runnable() {
         @Override
         public void run() {
            boolean finish = false;

            while (!finish && !closed) {
               try {
                  ClientTask task = getNextClientTask();

                  if (task == null) {
                     synchronized (tasks) {
                        tasks.wait();
                     }
                     continue;
                  }

                  task.runnable.run();
                  executingClients.remove(task.clientId);

               } catch (InterruptedException e) {
                  e.printStackTrace();
                  finish = true;
               }
            }
         }
      });
   }

   public void addTask(int clientId, Runnable task) {
      synchronized (tasks) {
         int nextIndex = findBestIndexToInsert(clientId);
         tasks.add(nextIndex, new ClientTask(clientId, task));

         if (!executingClients.contains(clientId)) {
            tasks.notify();
         }
      }
   }

   private int findBestIndexToInsert(int clientId) {
      int minIndex = 0;

      for (int i = 0; i < tasks.size(); ++i) {
         ClientTask task = tasks.get(i);
         if (task.clientId == clientId) {
            minIndex = i + 1;
         }
      }

      return minIndex < tasks.size() ? minIndex + 1 : minIndex;
   }

   public void close() {
      closed = true;

      synchronized (tasks) {
         tasks.notifyAll();
      }

      for (Thread thread : threads) {
         try {
            thread.join();
         } catch (InterruptedException ignored) {

         }
      }
   }
}

       long start = System.currentTimeMillis();

       long count = 0;
       for (int i = 0; i < 10000000; ++i) {
          if (args.length % (i+1) == 0) {
             count++;
          }
       }
       long end = System.currentTimeMillis();
       System.out.println("Count = " + count + "; execution time: "  + (end - start) + "ms");

1 2 3 4 5
add(7)
1 7 2 3 4 5
process(1)
7 2 3 4 5
add(1)
7 1 2 3 4 5
process(7)
1 2 3 4 5

1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 3 4 5 6 7

EP>1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 3 4 5 6 7
EP>

Не должно быть "повисших" клиентов, даже если клиентов больше, чем потоков.

EP>>1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 3 4 5 6 7
EP>>

Т.е. поток должен обрабатывать разных клиентов по-очереди, а не одного до завершения всех его задач.

package net.sf.brunneng;


import java.util.*;

public class ThreadPool {

   private class ClientTask {
      final int clientId;
      final Runnable runnable;

      public ClientTask(int clientId, Runnable runnable) {
         this.clientId = clientId;
         this.runnable = runnable;
      }
   }

   private static final int MAX_EXECUTED_CLIENTS_HISTORY = 100;

   private boolean closed;
   private final List<ClientTask> tasks = Collections.synchronizedList(new ArrayList<ClientTask>());

   private List<Thread> threads = new ArrayList<Thread>();
   private Set<Integer> executingClients = Collections.synchronizedSet(new HashSet<Integer>());

   private LinkedList<Integer> executedClientsHistory = new LinkedList<Integer>();

   public List<ClientTask> getTasks() {
      return tasks;
   }

   public ThreadPool(int threadsCount) {
      for (int i = 0; i < threadsCount; ++i) {
         Thread thread = createThread();
         threads.add(thread);
         thread.start();
      }
   }

   private ClientTask getNextClientTask() {
      ClientTask res = null;

      synchronized (tasks) {

         Map<Integer, Integer> clientIdToEarliestTaskInstanceMap = new HashMap<Integer, Integer>();
         for (int i = 0; i < tasks.size(); i++) {
            ClientTask task = tasks.get(i);
            if (!executingClients.contains(task.clientId) &&
                    !clientIdToEarliestTaskInstanceMap.containsKey(task.clientId)) {
               clientIdToEarliestTaskInstanceMap.put(task.clientId, i);
            }
         }

         final Map<Integer, Integer> clientIdMinStepsBack = new HashMap<Integer, Integer>();
         Iterator<Integer> iterator = executedClientsHistory.descendingIterator();
         int i = 1;
         while (iterator.hasNext()) {
            Integer clientId = iterator.next();
            if (!clientIdMinStepsBack.containsKey(clientId)) {
               clientIdMinStepsBack.put(clientId, i);
            }
            i++;
         }

         int maxStepBack = -1;
         Integer bestEarliestTaskIndex = null;
         for (Integer clientId : clientIdToEarliestTaskInstanceMap.keySet()) {
            Integer stepsBack = clientIdMinStepsBack.get(clientId);
            if (stepsBack == null) { // no occurence in history
               bestEarliestTaskIndex = clientIdToEarliestTaskInstanceMap.get(clientId);
               break;
            }
            else if (stepsBack > maxStepBack) {
               maxStepBack = stepsBack;
               bestEarliestTaskIndex = clientIdToEarliestTaskInstanceMap.get(clientId);
            }
         }

         if (bestEarliestTaskIndex != null) {
            res = tasks.remove(bestEarliestTaskIndex.intValue());
            executingClients.add(res.clientId);

            executedClientsHistory.add(res.clientId);
            if (executedClientsHistory.size() > MAX_EXECUTED_CLIENTS_HISTORY) {
               executedClientsHistory.removeFirst();
            }
         }
      }

      return res;
   }

   private Thread createThread() {
      return new Thread(new Runnable() {
         @Override
         public void run() {
            boolean finish = false;

            while (!finish && !closed) {
               try {
                  ClientTask task = getNextClientTask();

                  if (task == null) {
                     synchronized (tasks) {
                        tasks.wait();
                     }
                     continue;
                  }

                  task.runnable.run();
                  executingClients.remove(task.clientId);

               } catch (InterruptedException e) {
                  e.printStackTrace();
                  finish = true;
               }
            }
         }
      });
   }

   public void addTask(int clientId, Runnable task) {
      synchronized (tasks) {
         tasks.add(new ClientTask(clientId, task));

         if (!executingClients.contains(clientId)) {
            tasks.notify();
         }
      }
   }

   public void close() {
      closed = true;

      synchronized (tasks) {
         tasks.notifyAll();
      }

      for (Thread thread : threads) {
         try {
            thread.join();
         } catch (InterruptedException ignored) {

         }
      }
   }
}

CThreadPoolX::~CThreadPoolX()
{
    terminated = true;
    jobCV.notify_one();
    thread.join();
}

EP>* Каждый рабочий поток делает в цикле try_pop из очереди очередей клиентов. Если получилось достать очередь клиента — то делаем try_pop задания из его очереди, если задание есть — то выполняем его, потом очередь клиента ставится (push) в конец общей очереди.

S>CThreadPoolX::~CThreadPoolX()
S>{
S>    terminated = true;
S>    jobCV.notify_one();
S>    thread.join();
S>}
S>

CThreadPoolX::~CThreadPoolX()
{
}

void CWorkThread::ThreadFunc()
{
    std::unique_lock<std::mutex> lock(mutex);

    while (!this->terminated)
    {
        while (!this->task)
          cv.wait(lock);

        std::lock_guard<std::mutex> lockWorkFlag(busyFlag);

        try
        {
            std::cout << "Started  Client " + std::to_string(clientID)+" in workerThread " + std::to_string((int)this) + "\r\n";
            if (this->task)
                this->task->Execute();
        }
        catch (const std::exception &e)
        {
            //Log
        }

        this->task = nullptr;

        std::cout << "Finished Client " + std::to_string(clientID) + " in workerThread " + std::to_string((int)this) + "\r\n";

        clientTaskFinisher->FinishClientTask(clientID);
    }
}