1. Thread Pool Design
-
Concept: A thread pool is a mechanism for managing thread resources, where a certain number of threads are created in advance. When a task is submitted, a thread is obtained from the pool to execute the task, and after the task is completed, the thread is not destroyed but returned to the pool to wait for the next task.
-
Core Components:
-
Thread Manager: Responsible for creating, destroying, and managing threads.
-
Task Queue: Stores tasks to be executed.
-
Task Interface: Defines how tasks are executed.
-
C++ Implementation Example
#include <vector>#include <queue>#include <memory>#include <thread>#include <mutex>#include <condition_variable>#include <future>#include <functional>#include <stdexcept>class ThreadPool {public: ThreadPool(size_t threads); template<class F, class... Args> auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type>; ~ThreadPool();private: // Worker thread collection std::vector<std::thread> workers; // Task queue std::queue<std::function<void()>> tasks; // Synchronization related std::mutex queue_mutex; std::condition_variable condition; bool stop;};inline ThreadPool::ThreadPool(size_t threads) : stop(false) { for(size_t i = 0; i < threads; ++i) { workers.emplace_back([this] { while(true) { std::function<void()> task; { std::unique_lock<std::mutex> lock(this->queue_mutex); this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); }); if(this->stop && this->tasks.empty()) return; task = std::move(this->tasks.front()); this->tasks.pop(); } task(); } }); }}template<class F, class... Args>auto ThreadPool::enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> { using return_type = typename std::result_of<F(Args...)>::type; auto task = std::make_shared<std::packaged_task<return_type()>>( std::bind(std::forward<F>(f), std::forward<Args>(args)... )); std::future<return_type> res = task->get_future(); { std::unique_lock<std::mutex> lock(queue_mutex); // Do not allow adding tasks to a stopped thread pool if(stop) throw std::runtime_error("enqueue on stopped ThreadPool"); tasks.emplace([task]() { (*task)(); }); } condition.notify_one(); return res;}inline ThreadPool::~ThreadPool() { { std::unique_lock<std::mutex> lock(queue_mutex); stop = true; } condition.notify_all(); for(std::thread &&worker : workers) { worker.join(); }}-
Usage Example
// Create a thread pool with 4 threadsThreadPool pool(4);// Submit tasks to the thread poolstd::vector<std::future<int>> results;for(int i = 0; i < 8; ++i) { results.emplace_back( pool.enqueue([i] { std::cout << "hello " << i << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1)); std::cout << "world " << i << std::endl; return i*i; }) );}// Wait for all tasks to complete and get resultsfor(auto && result : results) std::cout << result.get() << ' ';std::cout << std::endl;2. Lock Optimization
Read-Write Locks
-
Concept: A read-write lock allows multiple threads to read shared resources simultaneously, but will exclusively occupy the resource during write operations, implementing a “multiple reads, single write” mechanism.
-
C++ Implementation:
#include <shared_mutex> // Introduced in C++17#include <mutex>#include <map>#include <string>class ThreadSafeHashMap {private: mutable std::shared_mutex mtx; std::map<std::string, int> data;public: // Read operation, allows multiple threads to proceed simultaneously int get(const std::string&& key) const { std::shared_lock<std::shared_mutex> lock(mtx); auto it = data.find(key); return it != data.end() ? it->second : -1; } // Write operation, exclusive lock void set(const std::string&& key, int value) { std::unique_lock<std::shared_mutex> lock(mtx); data[key] = value; }};-
Applicable Scenarios: Suitable for scenarios with many reads and few writes, such as caching systems.
Lock-Free Queues
-
Concept: A lock-free queue uses atomic operations instead of traditional locking mechanisms to avoid thread blocking and improve concurrency performance.
-
C++ Implementation (based on CAS operations):
#include <atomic>#include <memory>template<typename T>class LockFreeQueue {private: struct Node { T data; std::atomic<Node*> next; Node(const T&& value) : data(value), next(nullptr) {} }; std::atomic<Node*> head; std::atomic<Node*> tail;public: LockFreeQueue() : head(nullptr), tail(nullptr) {} void enqueue(const T&& value) { Node* newNode = new Node(value); Node* oldTail = tail.load(); while (!tail.compare_exchange_weak(oldTail, newNode)) {} if (oldTail) { oldTail->next = newNode; } else { head = newNode; } } bool dequeue(T&& value) { Node* oldHead = head.load(); while (oldHead) { Node* next = oldHead->next.load(); if (head.compare_exchange_weak(oldHead, next)) { value = oldHead->data; delete oldHead; return true; } } return false; } ~LockFreeQueue() { T value; while (dequeue(value)) {} }};-
Applicable Scenarios: Suitable for high-performance requirements in producer-consumer models.
Performance Comparison and Selection Strategy
|
Technology |
Advantages |
Disadvantages |
Applicable Scenarios |
|
Traditional Mutex |
Simple implementation, widely applicable |
Thread blocking, high context switch overhead |
Scenarios with low contention |
|
Read-Write Lock |
Improves read concurrency performance |
Complex implementation, write operations may suffer from starvation |
Scenarios with many reads and few writes |
|
Lock-Free Queue |
No blocking, high performance |
Complex implementation, difficult to debug |
Queue operations with high performance requirements |
In practical applications, it is necessary to choose the appropriate concurrency technology based on specific scenarios, and multiple technologies can be combined as needed to achieve optimal performance.