ThreadPool_Lambda Class Reference

Collaboration diagram for ThreadPool_Lambda:

Public Member Functions
	ThreadPool_Lambda (size_t num_threads)
	Construct a new Thread Pool object.
template<class F >
auto	enqueue (F f) -> std::future< decltype(f())>
	Enqueues a function for asynchronous execution.
	~ThreadPool_Lambda ()
	Destroy the Thread Pool object.

Detailed Description

Definition at line 30 of file ThreadPool_Lambda.cpp.

Constructor & Destructor Documentation

ThreadPool_Lambda()

ThreadPool_Lambda::ThreadPool_Lambda ( size_t  num_threads )

inline

Construct a new Thread Pool object.

Parameters

num_threads

The number of worker threads to spawn.

Definition at line 68 of file ThreadPool_Lambda.cpp.

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

~ThreadPool_Lambda()

ThreadPool_Lambda::~ThreadPool_Lambda ( )

inline

Destroy the Thread Pool object.

• Signals all workers to stop and joins them. Tasks already in the queue will be completed before destruction finishes.

Definition at line 110 of file ThreadPool_Lambda.cpp.

                         {
        stop = true;
        cv.notify_all(); // Wake up all threads to see the stop flag
        for (std::thread &worker : workers) {
            if (worker.joinable()) worker.join();
        }
    }

Member Function Documentation

enqueue()

template<class F >

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

inline

Enqueues a function for asynchronous execution.

• This template method wraps a function into a packaged_task, pushes it to the queue, and returns a future to track the result.

• Template Parameters

  F	The type of the function to be executed.

  Parameters

  f	The function (or lambda/bind) to execute.

  Returns

  std::future<decltype(f())> A future object to retrieve the function's result.

Definition at line 83 of file ThreadPool_Lambda.cpp.

                                                  {
        // 1. Determine the return type of the function dynamically
        using ReturnType = decltype(f());
 
        // 2. Wrap the function in a packaged_task shared pointer
        // Packaged tasks can only be moved, so we use shared_ptr to allow copying into the wrapper lambda.
        auto task = std::make_shared<std::packaged_task<ReturnType()>>(f);
 
        // 3. Extract the future "ticket" before sending the task to the queue
        std::future<ReturnType> res = task->get_future();
 
        {
            std::unique_lock<std::mutex> lock(queue_mtx);
            
            // 4. Wrap the task in a void() lambda so it fits our Task queue
            tasks.emplace([task]() { (*task)(); });
        }
 
        cv.notify_one(); // Wake up one idle worker
        return res;      // Return the future to the caller
    }

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_Lambda.cpp