C ++中的线程池设计

Question

I am not sure how to put this question in this forum any way i am asking and hopefully get some inputs.

I am writing a thread pool for my project. I have following design.

1. I am maintaining vector of threads std::vector<ThreadWrapper <threadFuncParam>* > m_vecThreads;

2. and pushing the threds in to list m_vecThreads.push_back(pThreadWrapper);

3. When new request comes i am taking the thread pool as below

    if(!m_vecThreads.empty() ) { ThreadWrapper <threadFuncParam>* pWrapper = m_vecThreads.back(); m_vecThreads.pop_back(); //... Awake threadd } 

4. When thread job is done it is pushed back in to pool of thread.

Now while gracefull shutdown i have stop the threads gracefully now with the design above i am facing problem how can i stop threads as in vector container i am poping from vector when request is serviced, so i lost the pointer till service is completed. Is there better i can do this or handle this scenario like map or other container which is supported by standard C++?

Another question is

During shutdown i have a scenario threads are doing process here in my case reading from database which may take time so i cannot wait till it is complete and i want to send reply to clients for pending requests which threads are processing and i am about to kill that value is bad.

Thanks!

Answer 1

If you still need access to what you pass out from your pool, then you should store the items in a "used" container.
However, at that moment, you are sharing your pointers, so you should use shared_ptr and pass out weak_ptr, so the threads can also be deleted and the users don't have a dangling pointer

The best cointainer for the used items would be a set, so the returned thread can be found and removed easily.

Answer 2

To solve your first problem, push it on to another vector, say m_vecBusyThreads , and when it's done, take it off there (note, you'll have to have some mechanism to search for the finished thread).

For your second problem, cleanest solution is to join each thread till it has "shutdown", any other approach could end up with some undesired side effects (esp. for example if it's connecting to a db etc.) Now that you have the busy container, iterate through tell each to shutdown, then iterate through each of your free containers, shutting down and joining each thread. Then go back to the busy container and attempt to join each thread. This may give a little time to the busy threads to shutdown cleanly.

boost::threads supports this concept of interrupt points, and the idea is that you can interrupt a thread at any of these points, however some calls are not interruptible (typically blocking calls), you need to find the best way to stop each type (socket read for example may be to send a dummy packet etc.)

Answer 3

I have done it in C, so the solution is not "C++"ish, but I was using two arrays: one containing the threads, and the other containing a representation of used / unused (~boolean).

I would be something like:

pthread_t[INITIAL_SIZE] thread_pool;
boolean[INITIAL_SIZE] threads_availability;
int first_available = 0;

pthread_t * get_thread() {
   int ind = 0;
   if (first_available<=INITIAL_SIZE) {
      ind = first_available;
      // find the next available spot
      for (first_available; first_available < INITIAL_SIZE && threads_availability[first_available]; first_available++);
      threads_availability[ind] = 0;

      return thread_pool[ind];
   }
}

void put_thread(pthread_t* thethread)
{
    int i = 0;
    pthread_t *it = thread_pool;
    while (!pthread_equals(it, thethread)) {
        it++;
        i++;
    }
    thread_availability[i] = 1;
}

please keep in mind that this is pseudo code, and this is not optimal. But this is an idea.

Answer 4

This is not a direct answer to your problem as other people already answered your original question.

I just wanted to say that you could look into boost::asio and/or boost::thread. I would probably go for boost::asio because it has everything you need to do asynchronous operations based on timers and whatnot. You could use shared_ptr and boost::enable_shared_from_this in order to let your "jobs" go and be destroyed automatically when they finish their job.

Example:

boost::shared_ptr<async_job> aj( new async_job(
   io_, boost::bind(&my_job::handle_completion, shared_from_this(), _1, _2)));

This code would execute your custom async_job on a thread pool (io_ is boost::asio::io_service). Your 'my_job' instance will be automatically destroyed when the async_job finishes and invokes handle_completion on it. Or you can let it live if you take shared_from_this() again inside handle_completion.

HTH, Alex