C++并发编程与线程池：高效并行的艺术

在现代软件开发中，并发编程已成为提升程序性能的重要手段。C++作为一门高性能的编程语言，提供了丰富的并发编程工具，其中线程池是实现高效并行的关键技术之一。本文将深入探讨C++并发编程的核心概念，并详细介绍线程池的设计与实现。

C++并发编程与线程池：高效并行的艺术

并发编程的基础

并发编程旨在同时执行多个任务，以提高程序的执行效率和响应速度。C++11标准引入了 <thread>、<mutex> 和 <future> 等头文件，极大地简化了并发编程的实现。

线程的创建与管理

在C++中，创建线程非常简单，只需包含 <thread> 头文件并使用 std::thread 类即可：

#include <thread>
#include <iostream>

void printHello() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(printHello);
    t.join();
    return 0;
}

同步与互斥

多线程环境下，数据的同步与互斥是保证程序正确性的关键。C++提供了多种同步机制，如 std::mutex、std::lock_guard 和 std::unique_lock：

#include <thread>
#include <mutex>
#include <iostream>

std::mutex mtx;

void printThreadId() {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::thread t1(printThreadId);
    std::thread t2(printThreadId);
    t1.join();
    t2.join();
    return 0;
}

线程池的概念与优势

尽管直接创建线程非常简单，但在高并发场景下，频繁创建和销毁线程会带来较大的性能开销。线程池通过预先创建一定数量的线程，并在需要时复用这些线程，有效减少了线程创建和销毁的开销。

线程池的优势

降低开销：避免了频繁创建和销毁线程的开销。
提高响应速度：任务到达时可以直接使用空闲线程，减少了等待时间。
资源控制：可以限制并发线程的数量，防止资源耗尽。

线程池的设计与实现

下面我们将实现一个简单的线程池，包含任务队列、线程管理和任务执行等功能。

任务队列

首先，我们需要一个任务队列来存储待执行的任务。可以使用 std::queue 结合 std::function 来实现：

#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class TaskQueue {
public:
    void push(std::function<void()> task) {
        std::lock_guard<std::mutex> lock(mtx);
        tasks.push(task);
        cv.notify_one();
    }

    std::function<void()> pop() {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this] { return !tasks.empty(); });
        auto task = tasks.front();
        tasks.pop();
        return task;
    }

private:
    std::queue<std::function<void()>> tasks;
    std::mutex mtx;
    std::condition_variable cv;
};

线程管理

接下来，我们需要管理线程的创建和销毁。可以定义一个 ThreadPool 类来管理这些线程：

#include <vector>
#include <thread>

class ThreadPool {
public:
    ThreadPool(size_t numThreads) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    auto task = taskQueue.pop();
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        for (auto& worker : workers) {
            worker.join();
        }
    }

    void enqueue(std::function<void()> task) {
        taskQueue.push(task);
    }

private:
    TaskQueue taskQueue;
    std::vector<std::thread> workers;
};

使用线程池

现在，我们可以使用线程池来执行并发任务：

#include <iostream>

void printNumber(int num) {
    std::cout << "Number: " << num << std::endl;
}

int main() {
    ThreadPool pool(4);

    for (int i = 0; i < 10; ++i) {
        pool.enqueue([i] { printNumber(i); });
    }

    return 0;
}