C++11 Dynamic Threadpool

Question

Recently, i've been trying to find a library for threading concurrent tasks. Ideally, a simple interface that calls a function on a thread. There are n number of threads at any time, some complete faster than others and arrive at different times.

First i was trying Rx, which is great in c++. I've also looked into Blocks and TBB but they are either platform dependant. For my prototype, i need to remain platform independent as we don't know what it will be running on yet and can change when decisions are made.

C++11 has a number of things for threading and concurrency and i found a number of examples like this one for thread pools.

https://github.com/bilash/threadpool

Similar projects use the same lambda expressions with std::thread and std::mutex.

This looks perfect for what i need. There some issues. The pools are started with a defined number of threads and tasks are queued until a thread is free.

How can i add new threads? Remove expired threads? (.Join()??)

Obviously, this is much easier for a known number of threads as they can be initialised in the ctor and then join() in the dtor.

Any tips or pointers here from someone with experience with C++ concurrency?

GCD or libdispatch http://en.wikipedia.org/wiki/Grand_Central_Dispatch — Bryan Chen, Feb 26 '14 at 01:45
I use Boost::Asio for a simple threadpool. Maybe you want to have a look at this sample http://stackoverflow.com/q/14265676/991425 — Haatschii, Feb 26 '14 at 01:50
Yup. I've read about GCD. Any example or tutorial sources for this in C++? IS boost supported across platforms? — WebSight, Feb 26 '14 at 01:54
I never had any porting issues with Boost. If we are talking about WIN/Linux/OSX, there should be no problem at all. — Haatschii, Feb 26 '14 at 02:01

score 10 · Accepted Answer · edited Sep 15 '15 at 19:16

Start with maximum number of threads a system can support:
```
int Num_Threads =  thread::hardware_concurrency();
```
For an efficient threadpool implementation, once threads are created according to Num_Threads, it's better not to create new ones, or destroy old ones (by joining). There will be performance penalty, might even make your application goes slower than the serial version.

Each C++11 thread should be running in their function with an infinite loop, constantly waiting for new tasks to grab and run.

Here is how to attach such function to the thread pool:
```
int Num_Threads = thread::hardware_concurrency();
vector<thread> Pool;
for(int ii = 0; ii < Num_Threads; ii++)
{  Pool.push_back(thread(Infinite_loop_function));}
```

The Infinite_loop_function

This is a "while(true)" loop waiting for the task queue

void The_Pool:: Infinite_loop_function()
{
    while(true)
    {
        {
            unique_lock<mutex> lock(Queue_Mutex);

            condition.wait(lock, []{return !Queue.empty()});
            Job = Queue.front();
            Queue.pop();
        }
        Job(); // function<void()> type
    }
};

Make a function to add job to your Queue

void The_Pool:: Add_Job(function<void()> New_Job)
{
    {
        unique_lock<mutex> lock(Queue_Mutex);
        Queue.push(New_Job);
    }
    condition.notify_one();
}

Bind an arbitrary function to your Queue

Pool_Obj.Add_Job(std::bind(&Some_Class::Some_Method, &Some_object));

Once you integrate these ingredients, you have your own dynamic threading pool. These threads always run, waiting for jobs to do.

score 0 · Answer 2 · answered Dec 11 '19 at 15:29

This should be simple to use: https://pocoproject.org/docs/Poco.ThreadPool.html

A thread pool always keeps a number of threads running, ready to accept work. Creating and starting a threads can impose a significant runtime overhead to an application. A thread pool helps to improve the performance of an application by reducing the number of threads that have to be created (and destroyed again). Threads in a thread pool are re-used once they become available again. The thread pool always keeps a minimum number of threads running. If the demans for threads increases, additional threads are created. Once the demand for threads sinks again, no-longer used threads are stopped and removed from the pool.

ThreadPool(
    int minCapacity = 2,
    int maxCapacity = 16,
    int idleTime = 60,
    int stackSize = 0
);

This is very nice library and easy to use not like Boost :(

https://github.com/pocoproject/poco

C++11 Dynamic Threadpool

2 Answers2

Linked