Capstone 1: Thread-Safe Concurrent Task Queue & Thread Pool

Advanced17 min read•Updated: 2026-10-22

🏭 Capstone Project 1: Thread-Safe Task Queue & Thread Pool

Introduction

Spawning a fresh OS thread for every brief task incurs massive overhead. In high-performance backend engines, a pre-warmed Thread Pool maintains a fixed set of worker threads that continuously pull jobs from a synchronized concurrent task queue.

🎯 Architecture

Pre-spawns worker threads according to CPU hardware concurrency.
Thread-safe task queue synchronized with std::mutex and std::condition_variable.
Supports arbitrary callable lambdas using std::function<void()>.

💻 Full Source Code

1#include <iostream>
2#include <vector>
3#include <queue>
4#include <thread>
5#include <mutex>
6#include <condition_variable>
7#include <functional>
8 
9class ThreadPool {
10private:
  std::vector<std::jthread> m_workers;
  std::queue<std::function<void()>> m_taskQueue;
  std::mutex m_queueMutex;
  std::condition_variable m_cv;
  bool m_stop = false;
16 
17public:
  explicit ThreadPool(std::size_t threadCount) {
      for (std::size_t i = 0; i < threadCount; ++i) {
          m_workers.emplace_back([this, i]() {
              while (true) {
                  std::function<void()> task;
                  {
                      std::unique_lock<std::mutex> lock(m_queueMutex);
                      m_cv.wait(lock, [this]() {
                          return m_stop || !m_taskQueue.empty();
                      });
28 
                      if (m_stop && m_taskQueue.empty()) {
                          return; // Exit thread cleanly
                      }
32 
                      task = std::move(m_taskQueue.front());
                      m_taskQueue.pop();
                  }
                  task(); // Execute task outside lock!
              }
          });
      }
  }
41 
  template <typename F>
  void enqueue(F&& f) {
      {
          std::lock_guard<std::mutex> lock(m_queueMutex);
          m_taskQueue.emplace(std::forward<F>(f));
      }
      m_cv.notify_one();
  }
50 
  ~ThreadPool() {
      {
          std::lock_guard<std::mutex> lock(m_queueMutex);
          m_stop = true;
      }
      m_cv.notify_all();
  }
58};
59 
60int main() {
  std::cout << "=== MSK Concurrent Thread Pool v1.0 ===\n";
  ThreadPool pool(4); // 4 Worker Threads
63 
  // Enqueue 8 parallel tasks:
  for (int i = 1; i <= 8; ++i) {
      pool.enqueue([i]() {
          std::cout << "[Worker ID: " << std::this_thread::get_id() << "] Completed Task #" << i << "\n";
      });
  }
70 
  std::this_thread::sleep_for(std::chrono::milliseconds(200));
  std::cout << "All pool tasks finished cleanly.\n";
  return 0;
74}

Next Lesson

Capstone 2: High-Performance LRU (Least Recently Used) Cache Engine

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Introduction to C++20 Ranges & Views	Capstone 2: High-Performance LRU (Least Recently Used) Cache Engine

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

💻 Full Source Code

1#include <iostream>
2#include <vector>
3#include <queue>
4#include <thread>
5#include <mutex>
6#include <condition_variable>
7#include <functional>
8 
9class ThreadPool {
10private:
  std::vector<std::jthread> m_workers;
  std::queue<std::function<void()>> m_taskQueue;
  std::mutex m_queueMutex;
  std::condition_variable m_cv;
  bool m_stop = false;
16 
17public:
  explicit ThreadPool(std::size_t threadCount) {
      for (std::size_t i = 0; i < threadCount; ++i) {
          m_workers.emplace_back([this, i]() {
              while (true) {
                  std::function<void()> task;
                  {
                      std::unique_lock<std::mutex> lock(m_queueMutex);
                      m_cv.wait(lock, [this]() {
                          return m_stop || !m_taskQueue.empty();
                      });
28 
                      if (m_stop && m_taskQueue.empty()) {
                          return; // Exit thread cleanly
                      }
32 
                      task = std::move(m_taskQueue.front());
                      m_taskQueue.pop();
                  }
                  task(); // Execute task outside lock!
              }
          });
      }
  }
41 
  template <typename F>
  void enqueue(F&& f) {
      {
          std::lock_guard<std::mutex> lock(m_queueMutex);
          m_taskQueue.emplace(std::forward<F>(f));
      }
      m_cv.notify_one();
  }
50 
  ~ThreadPool() {
      {
          std::lock_guard<std::mutex> lock(m_queueMutex);
          m_stop = true;
      }
      m_cv.notify_all();
  }
58};
59 
60int main() {
  std::cout << "=== MSK Concurrent Thread Pool v1.0 ===\n";
  ThreadPool pool(4); // 4 Worker Threads
63 
  // Enqueue 8 parallel tasks:
  for (int i = 1; i <= 8; ++i) {
      pool.enqueue([i]() {
          std::cout << "[Worker ID: " << std::this_thread::get_id() << "] Completed Task #" << i << "\n";
      });
  }
70 
  std::this_thread::sleep_for(std::chrono::milliseconds(200));
  std::cout << "All pool tasks finished cleanly.\n";
  return 0;
74}

Previous Lesson

Next Lesson

Introduction to C++20 Ranges & Views

Capstone 2: High-Performance LRU (Least Recently Used) Cache Engine