alexge233 / threadible

A C++11 Header-Only Asynchronous Thread Pool for easy queuing tasks in an OOP manner

A C++11 Header only class, which allows you to use a one-time thread pool in an asynchronous (Event IO) way, by enapsulating your tasks or jobs in classes (OOP). For the benefits of thread-pools, please read the #Wikipedia article which summarizes what you gain.

This is a header-only library, so all you need is threadible.hpp and the associated boost headers:

Dependencies

• libboost headers, thread and system

Building

There's nothing to build, just take a look at example.cpp If however you wanna see the example in action, then:

mkdir build
cd build
cmake ..
make
./thread_pool

Example

The example uses a minified and naive approach:

• each task is allocated a resource
• threadible has a set amount of available concurrent threads
• threadible has a set amount of resources/assets

The idea is simple:

• you add tasks (either data structures or functors)
• each one of your asset objects handles a task
• the queue in the thread pool will execute asynchronously and in parallel each task until no tasks remain
• you can arbitrarily add more tasks when/if needed

The approach is simple; you can pre-allocate thread-specific memory, objects or handlers, and thus parallelise execution without worrying about sharing memory objects (you can of course still do that).

Execution uses boost's ASIO, and C++ std::thread so it should be very easy to port under different platforms, provided you have a fairly recent compiler.

See the example.cpp for a minified demonstration.

threadible's Issues

expose methods instead

threadible/threadible.hpp

Line 15 in d9f99cb

* a public `std::mutex` accessible,

Rather than requiring a public std::mutex variable, ask that the templated class exposes two methods: try_lock and unlock?

Same here, try with `std::atomic`

threadible/threadible.hpp

Line 117 in d9f99cb

std::unique_lock<std::mutex> lock(_mtx);

Same here, replace with `std::atomic`

threadible/threadible.hpp

Line 107 in d9f99cb

if (--_tasks == 0) {

replace with an `std::atomic` if possible

threadible/threadible.hpp

Line 71 in d9f99cb

_cv.wait(lock, [this] { return _tasks == 0; });

Not sure how conditional variable will behave with std::atomic but test it to see?