Boost – Thread pool
Boost Library
- Boost is a collection of high-quality C++ libraries and works on almost any modern operating system, including UNIX and Windows variants
Compiling boost library
bjam toolset=msvc-6.0 link=static link=dynamic threading=multi
Features
Policy-based thread pool implementation
- Scheduling policies: fifo, lifo and priority
- Size policies: static_size
- Size policy controller: empty_controller, resize_controller
- Shutdown policies: wait_for_all_tasks, wait_for_active_tasks, immediately
Smooth integration into STL and boost
Basic constructs
Create thread pool
boost::threadpool::pool threadPool;
Schedule job
threadPool.schedule(&workerfunction);
Wait for completion
threadPool.wait();
Boost bind
m_tp.schedule(boost::bind(boost::mem_fn(&CDataProcessor::ProcessBuffer), this, iBuffPos));
Illustration – 1
#include "threadpool.hpp“ using namespace boost::threadpool; // Some example tasks void first_task() { ... } void second_task() { ... } void execute_with_threadpool() { // Create a thread pool. pool tp(2); // Add some tasks to the pool. tp.schedule(&first_task); tp.schedule(&second_task); // Leave this function and wait until all tasks are finished. }
Illustration – 2
scoped_pool<prio_pool, 0> tp; // Add some tasks to the pool. tp += prio_task_func(5, &normal_task); tp += prio_task_func(100, &important_task); tp += prio_task_func(7, &normal_task); // Add the some threads to the pool. This will start the execution of the tasks. tp->resize(2); // The tasks are processed according to their priority: important_task(100), nonrelevant_task(7), nonrelevant_task(5). tp->wait();
Thread synchronization
Mutex
- Protection against data races and allows thread-safe synchronization of data between threads.
- Lockable, TimedLockable, SharedLockable and UpgradeLockable
Condition variables
- Provide a mechanism for one thread to wait for notification from another thread that a particular condition has become true.
One-Time Initialization
- Mechanism for ensuring that an initialization routine is run exactly once without data races or deadlocks
Barriers
- A barrier is configured for a particular number of threads (n), and as threads reach the barrier they must wait until all n threads have arrived
Thread synchronization
One-Time Initialization
#include <boost/threadpool.hpp> #include <boost/thread/once.hpp> int value=0; boost::once_flag once = BOOST_ONCE_INIT; void init() { ++value; } void thread_proc() { boost::call_once(&init, once); } int main(int argc, char* argv[]) { boost::threadpool::pool tp(2); tp.schedule(&thread_proc); tp.schedule(&thread_proc); tp.wait(); }
#include <boost/thread/thread.hpp> #include <boost/thread/once.hpp> #include <cassert> int value=0; boost::once_flag once = BOOST_ONCE_INIT; void init() { ++value; } void thread_proc() { boost::call_once(&init, once); } int main(int argc, char* argv[]) { boost::thread_group threads; for (int i=0; i<5; ++i) threads.create_thread(&thread_proc); threads.join_all(); assert(value == 1); }
😎