pool::ThreadPool Class Reference

A simple thread pool implementation. More...

#include "thread_pool.h"

Public Member Functions
	ThreadPool (unsigned numThreads)
	Constructs a ThreadPool with a specified number of threads.
	~ThreadPool ()
	Destroys the ThreadPool, joining all threads.
	ThreadPool (const ThreadPool &)=delete
ThreadPool &	operator= (const ThreadPool &)=delete
	ThreadPool (ThreadPool &&)=delete
ThreadPool &	operator= (ThreadPool &&)=delete
template<class F , class... Args>
std::future< std::invoke_result_t< F, Args... > >	enqueue (F &&f, Args &&... args)
	Enqueues a task to be executed by the thread pool.
void	wait ()
	Waits for all tasks in the thread pool to finish.
unsigned	getAvailableThreads ()
	Returns the number of threads available for executing tasks.

Detailed Description

A simple thread pool implementation.

Definition at line 28 of file thread_pool.h.

Constructor & Destructor Documentation

ThreadPool() [1/3]

pool::ThreadPool::ThreadPool ( unsigned  numThreads )

explicit

Constructs a ThreadPool with a specified number of threads.

Parameters

numThreads

The number of threads in the pool.

Definition at line 21 of file thread_pool.cpp.

    {
        _workers.reserve(numThreads);
        for (unsigned i = 0; i < numThreads; ++i)
        {
            _workers.emplace_back(
                [this]
                {
                    while (true)
                    {
                        Task task;
                        {
                            std::unique_lock lock(_queue_mutex);
                            _condition.wait(lock, [this] { return _stop || !_tasks.empty(); });
                            if (_stop && _tasks.empty())
                            {
                                return;
                            }
                            task = std::move(_tasks.front());
                            _tasks.pop();
                        }
                        try
                        {
                            task();
                        }
                        catch (const std::exception& e)
                        {
                            LOG(logging::Level::ERROR, "Exception in thread pool: {}", e.what());
                        }
 
                        {
                            std::unique_lock lock(_queue_mutex);
                            --_pending_tasks;
                            if (_pending_tasks == 0)
                            {
                                _done_condition.notify_all();
                            }
                        }
                    }
                });
        }
    }

References logging::ERROR, and LOG.

~ThreadPool()

pool::ThreadPool::~ThreadPool

(

)

Destroys the ThreadPool, joining all threads.

Definition at line 64 of file thread_pool.cpp.

    {
        {
            std::unique_lock lock(_queue_mutex);
            _stop = true;
            _condition.notify_all();
        }
        for (std::thread& worker : _workers)
        {
            worker.join();
        }
    }

ThreadPool() [2/3]

pool::ThreadPool::ThreadPool ( const ThreadPool &  )

delete

ThreadPool() [3/3]

pool::ThreadPool::ThreadPool ( ThreadPool &&  )

delete

Member Function Documentation

enqueue()

template<class F , class... Args>

std::future< std::invoke_result_t< F, Args... > > pool::ThreadPool::enqueue	(	F &&	f,
		Args &&...	args
	)

Enqueues a task to be executed by the thread pool.

Template Parameters

F	The type of the function to be executed.
Args	The types of the arguments to the function.

Parameters

f	The function to be executed.
args	The arguments to the function.

Returns

A future that will hold the result of the function.

Exceptions

std::runtime_error

if the thread pool is stopped.

Definition at line 57 of file thread_pool.h.

        {
            using ReturnType = std::invoke_result_t<F, Args...>;
 
            auto task = std::make_shared<std::packaged_task<ReturnType()>>(
                std::bind(std::forward<F>(f), std::forward<Args>(args)...));
 
            std::future<ReturnType> res = task->get_future();
            {
                std::unique_lock lock(_queue_mutex);
                if (_stop)
                {
                    throw std::runtime_error("enqueue on stopped ThreadPool");
                }
 
                ++_pending_tasks;
                _tasks.emplace([task] { (*task)(); });
                _condition.notify_one();
            }
            return res;
        }

getAvailableThreads()

unsigned pool::ThreadPool::getAvailableThreads

(

)

Returns the number of threads available for executing tasks.

Returns

The number of available threads.

Definition at line 77 of file thread_pool.cpp.

    {
        std::unique_lock lock(_queue_mutex);
        const unsigned active_threads = _pending_tasks;
        if (_workers.size() > static_cast<std::size_t>(std::numeric_limits<unsigned>::max()))
        {
            throw std::runtime_error("Thread pool size exceeds unsigned range.");
        }
        const unsigned total_threads = static_cast<unsigned>(_workers.size());
        return total_threads > active_threads ? total_threads - active_threads : 0;
    }

operator=() [1/2]

ThreadPool & pool::ThreadPool::operator= ( const ThreadPool &  )

delete

operator=() [2/2]

ThreadPool & pool::ThreadPool::operator= ( ThreadPool &&  )

delete

wait()

void pool::ThreadPool::wait

(

)

Waits for all tasks in the thread pool to finish.

Definition at line 82 of file thread_pool.h.

        {
            std::unique_lock lock(_queue_mutex);
            _done_condition.wait(lock, [this] { return _pending_tasks == 0; });
        }

---

The documentation for this class was generated from the following files:

• packages/libfers/src/core/thread_pool.h
• packages/libfers/src/core/thread_pool.cpp