ThreadPool_Advanced Class Reference

A pool of persistent worker threads for concurrent task execution. More...

Collaboration diagram for ThreadPool_Advanced:

Public Member Functions
	ThreadPool_Advanced (size_t num_threads)
	Initializes the thread pool with a specified number of threads.
template<class F >
auto	enqueue (F f) -> std::future< decltype(f())>
	Adds a task to the pool and returns a future for the result.
	~ThreadPool_Advanced ()
	Gracefully shuts down the thread pool.

Detailed Description

A pool of persistent worker threads for concurrent task execution.

• The ThreadPool manages a fixed set of threads that pull tasks from a thread-safe queue. It supports tasks with arbitrary return values via the enqueue method.

Definition at line 59 of file ThreadPool_Advanced.cpp.

Constructor & Destructor Documentation

ThreadPool_Advanced()

ThreadPool_Advanced::ThreadPool_Advanced ( size_t  num_threads )

inline

Initializes the thread pool with a specified number of threads.

Parameters

num_threads

Number of worker threads to create.

Definition at line 96 of file ThreadPool_Advanced.cpp.

                                            : stop(false) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back(&ThreadPool_Advanced::workerLoop, this);
        }
    }

~ThreadPool_Advanced()

ThreadPool_Advanced::~ThreadPool_Advanced ( )

inline

Gracefully shuts down the thread pool.

• Sets the stop flag, notifies all workers, and joins them to ensure all threads finish execution.

Definition at line 133 of file ThreadPool_Advanced.cpp.

                           {
        stop = true;
        cv.notify_all();
        for (std::thread &worker : workers) {
            if (worker.joinable()) worker.join();
        }
    }

Member Function Documentation

enqueue()

template<class F >

auto ThreadPool_Advanced::enqueue ( F  f ) -> std::future<decltype(f())>

inline

Adds a task to the pool and returns a future for the result.

• Uses template meta-programming to deduce the return type of the provided function.

• Template Parameters

  F	Type of the function or functor.

  Parameters

  f	The task to execute.

  Returns

  std::future<decltype(f())> A future object to access the task's return value.

Definition at line 110 of file ThreadPool_Advanced.cpp.

                                                  {
        using ReturnType = decltype(f());
 
        // Packaged tasks handle the storage of the return value or exceptions.
        auto task = std::make_shared<std::packaged_task<ReturnType()>>(f);
        
        std::future<ReturnType> res = task->get_future();
 
        {
            std::unique_lock<std::mutex> lock(queue_mtx);
            // Lambda captures the shared_ptr by value to extend its lifetime.
            tasks.emplace([task]() { (*task)(); });
        }
 
        cv.notify_one();
        return res;
    }

Referenced by main().

Here is the caller graph for this function:

---

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

• Request-Response/ThreadPool_Advanced.cpp