Thread pooling in C 11

Question

Relevant questions   About C  11    C  11  std  thread pooled  Will async launch  async  in C  11 make thread pools obsolete for avoiding expensive thread creation    About Boost    C   boost thread reusing threads boost  thread and creating a pool of them      How do I get a pool of threads to send tasks to  without creating and deleting them over and over again  This means persistent threads to resynchronize without joining     I have code that looks like this   namespace     std  vector lt std  thread gt  workers     int total   4    int arr 4     0      void each thread does int i        arr i     2         int main int argc  char  argv        for  int i   0  i  lt  8    i       for 8 iterations      for  int j   0  j  lt  4    j          workers push back std  thread each thread does  j              for  std  thread  amp t  workers          if  t joinable              t join                      arr 4    std  min element arr  arr 4         return 0      Instead of creating and joining threads each iteration  I d prefer to send tasks to my worker threads each iteration and only create them once

User · Answer

A threadpool is at core a set of threads all bound to a function working as an event loop. These threads will endlessly wait for a task to be executed, or their own termination.

The threadpool job is to provide an interface to submit jobs, define (and perhaps modify) the policy of running these jobs (scheduling rules, thread instantiation, size of the pool), and monitor the status of the threads and related resources.

So for a versatile pool, one must start by defining what a task is, how it is launched, interrupted, what is the result (see the notion of promise and future for that question), what sort of events the threads will have to respond to, how they will handle them, how these events shall be discriminated from the ones handled by the tasks. This can become quite complicated as you can see, and impose restrictions on how the threads will work, as the solution becomes more and more involved.

The current tooling for handling events is fairly barebones(*): primitives like mutexes, condition variables, and a few abstractions on top of that (locks, barriers). But in some cases, these abstrations may turn out to be unfit (see this related question), and one must revert to using the primitives.

Other problems have to be managed too:

signal
i/o
hardware (processor affinity, heterogenous setup)

How would these play out in your setting?

This answer to a similar question points to an existing implementation meant for boost and the stl.

I offered a very crude implementation of a threadpool for another question, which doesn't address many problems outlined above. You might want to build up on it. You might also want to have a look of existing frameworks in other languages, to find inspiration.

_{(*) I don't see that as a problem, quite to the contrary. I think it's the very spirit of C++ inherited from C.}

User · Answer

You can use thread pool from boost library   void my task         int main        int threadNumbers   thread  hardware concurrency        boost  asio  thread pool pool threadNumbers           Submit a function to the pool      boost  asio  post pool  my task           Submit a lambda object to the pool      boost  asio  post pool                                 You also can use threadpool from open source community   void first task             void second task          int main        int threadNumbers   thread  hardware concurrency        pool tp threadNumbers           Add some tasks to the pool      tp schedule  amp first task       tp schedule  amp second task

User · Answer

Edit  This now requires C  17 and concepts   As of 9 12 16  only g   6 0  is sufficient    The template deduction is a lot more accurate because of it  though  so it s worth the effort of getting a newer compiler  I ve not yet found a function that requires explicit template arguments   It also now takes any appropriate callable object  and is still statically typesafe       It also now includes an optional green threading priority thread pool using the same API  This class is POSIX only  though  It uses the ucontext t API for userspace task switching     I created a simple library for this  An example of usage is given below   I m answering this because it was one of the things I found before I decided it was necessary to write it myself    bool is prime int n        Determine if n is prime     int main      thread pool pool 8      8 threads    list lt future lt bool gt  gt  results    for int n   2 n  lt  10000 n            Submit a job to the pool      results emplace back pool async is prime  n           int n   2    for auto i   results begin   i    results end   i    n            i is an iterator pointing to a future representing the result of is prime n      cout  lt  lt  n  lt  lt           bool prime   i- gt get       Wait for the task is prime n  to finish and get the result      if prime        cout  lt  lt   is prime       else       cout  lt  lt   is not prime       cout  lt  lt  endl            You can pass async any function with any  or void  return value and any  or no  arguments and it will return a corresponding std  future  To get the result  or just wait until a task has completed  you call get   on the future   Here s the github  https   github com Tyler-Hardin thread pool

User · Answer

A threadpool with no dependencies outside of STL is entirely possible  I recently wrote a small header-only threadpool library to address the exact same problem  It supports dynamic pool resizing  changing the number of workers at runtime   waiting  stopping  pausing  resuming and so on  I hope you find it useful

User · Answer

A pool of threads means that all your threads are running  all the time  ndash  in other words  the thread function never returns  To give the threads something meaningful to do  you have to design a system of inter-thread communication  both for the purpose of telling the thread that there s something to do  as well as for  communicating the actual work data   Typically this will involve some kind of concurrent data structure  and each thread would presumably sleep on some kind of condition variable  which would be notified when there s work to do  Upon receiving the notification  one or several of the threads wake up  recover a task from the concurrent data structure  process it  and store the result in an analogous fashion   The thread would then go on to check whether there s even more work to do  and if not go back to sleep   The upshot is that you have to design all this yourself  since there isn t a natural notion of  work  that s universally applicable  It s quite a bit of work  and there are some subtle issues you have to get right   You can program in Go if you like a system which takes care of thread management for you behind the scenes

User · Answer

You can use C   Thread Pool Library  https   github com vit-vit ctpl   Then the code your wrote can be replaced with the following   include  lt ctpl h gt      or  lt ctpl stl h gt  if ou do not have Boost library  int main  int argc  char  argv          ctpl  thread pool p 2    two threads in the pool          int arr 4     0       std  vector lt std  future lt void gt  gt  results 4       for  int i   0  i  lt  8    i       for 8 iterations          for  int j   0  j  lt  4    j                results j    p push   amp arr  j  int   arr j    2                        for  int j   0  j  lt  4    j                results j  get                      arr 4    std  min element arr  arr   4             You will get the desired number of threads and will not create and delete them over and over again on the iterations

User · Answer

Something like this might help  taken from a working app     include  lt memory gt   include  lt boost asio hpp gt   include  lt boost thread hpp gt   struct thread pool     typedef std  unique ptr lt boost  asio  io service  work gt  asio worker     thread pool int threads   service    service worker new asio worker  element type service         for  int i   0  i  lt  threads    i          auto worker    this    return service run             grp add thread new boost  thread worker                 template lt class F gt    void enqueue F f        service post f           thread pool         service worker reset        grp join all        service stop         private    boost  asio  io service service    asio worker service worker    boost  thread group grp       You can use it like this   thread pool pool 2    pool enqueue        std  cout  lt  lt   Hello from Task 1 n        pool enqueue        std  cout  lt  lt   Hello from Task 2 n         Keep in mind that reinventing an efficient asynchronous queuing mechanism is not trivial   Boost  asio  io service is a very efficient implementation  or actually is a collection of platform-specific wrappers  e g  it wraps I O completion ports on Windows

User · Answer

This is copied from my answer to another very similar post  hope it can help   1  Start with maximum number of threads a system can support   int Num Threads    thread  hardware concurrency      2  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 lt thread gt  Pool  for int ii   0  ii  lt  Num Threads  ii       Pool push back thread Infinite loop function       3  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 lt mutex gt  lock Queue Mutex                condition wait lock     return  Queue empty      terminate pool                Job   Queue front                Queue pop                      Job       function lt void   gt  type            4  Make a function to add job to your Queue  void The Pool   Add Job function lt void   gt  New Job                  unique lock lt mutex gt  lock Queue Mutex           Queue push New Job             condition notify one        5  Bind an arbitrary function to your Queue  Pool Obj Add Job std  bind  amp Some Class  Some Method   amp Some object      Once you integrate these ingredients  you have your own dynamic threading pool  These threads always run  waiting for job to do   I apologize if there are some syntax errors  I typed these code and and I have a bad memory  Sorry that I cannot provide you the complete thread pool code  that would violate my job integrity   Edit  to terminate the pool  call the shutdown   method   XXXX  shutdown          unique lock lt mutex gt  lock threadpool mutex       terminate pool   true      use this flag in condition wait      condition notify all       wake up all threads          Join all threads      for std  thread  amp every thread   thread vector          every thread join          thread vector clear          stopped   true     use this flag in destructor  if not set  call shutdown

User · Answer

This is another thread pool implementation that is very simple  easy to understand and use  uses only C  11 standard library  and can be looked at or modified for your uses  should be a nice starter if you want to get into using thread pools    https   github com progschj ThreadPool

User · Answer

Follwoing  PhD EcE  https   stackoverflow com users 3818417 phd-ece  suggestion  I implemented the thread pool       function pool h    pragma once  include  lt queue gt   include  lt functional gt   include  lt mutex gt   include  lt condition variable gt   include  lt atomic gt   include  lt cassert gt   class Function pool    private      std  queue lt std  function lt void   gt  gt  m function queue      std  mutex m lock      std  condition variable m data condition      std  atomic lt bool gt  m accept functions   public       Function pool         Function pool        void push std  function lt void   gt  func       void done        void infinite loop func            function pool cpp    include  function pool h   Function pool  Function pool     m function queue    m lock    m data condition    m accept functions true       Function pool   Function pool        void Function pool  push std  function lt void   gt  func        std  unique lock lt std  mutex gt  lock m lock       m function queue push func          when we send the notification immediately  the consumer will try to get the lock   so unlock asap     lock unlock        m data condition notify one       void Function pool  done         std  unique lock lt std  mutex gt  lock m lock       m accept functions   false      lock unlock           when we send the notification immediately  the consumer will try to get the lock   so unlock asap     m data condition notify all          notify all waiting threads     void Function pool  infinite loop func         std  function lt void   gt  func      while  true                              std  unique lock lt std  mutex gt  lock m lock               m data condition wait lock   this     return  m function queue empty       m accept functions                  if   m accept functions  amp  amp  m function queue empty                                    lock will be release automatically                    finish the thread loop and let it join in the main thread                  return                            func   m function queue front                m function queue pop                  release the lock                   func                 main cpp    include  function pool h   include  lt string gt   include  lt iostream gt   include  lt mutex gt   include  lt functional gt   include  lt thread gt   include  lt vector gt   Function pool func pool   class quit worker exception   public std  exception      void example function         std  cout  lt  lt   bla   lt  lt  std  endl     int main         std  cout  lt  lt   stating operation   lt  lt  std  endl      int num threads   std  thread  hardware concurrency        std  cout  lt  lt   number of threads      lt  lt  num threads  lt  lt  std  endl      std  vector lt std  thread gt  thread pool      for  int i   0  i  lt  num threads  i                  thread pool push back std  thread  amp Function pool  infinite loop func   amp func pool                 here we should send our functions     for  int i   0  i  lt  50  i                  func pool push example function             func pool done        for  unsigned int i   0  i  lt  thread pool size    i                  thread pool at i  join

[c++] Thread pooling in C++11

Examples related to c++

Examples related to multithreading

Examples related to c++11

Examples related to threadpool

Examples related to stdthread