C++ 多线程详解：从基础到应用

最新推荐文章于 2024-10-09 10:07:13 发布

Crazy learner

最新推荐文章于 2024-10-09 10:07:13 发布

阅读量924

点赞数 17

分类专栏： C++与python编程文章标签： c++

本文链接：https://blog.csdn.net/weixin_52734695/article/details/142105937

版权

C++与python编程专栏收录该内容

53 篇文章 1 订阅

订阅专栏

在现代应用中，多线程成为了提升程序性能的重要工具。特别是当我们希望充分利用多核 CPU 的计算能力时，C++ 提供了强大的多线程支持，可以并发地执行多个任务。今天，我们将通过易懂的讲解与实际的代码示例，帮助你掌握 C++ 中的多线程编程。

一、什么是多线程？

简单来说，多线程允许程序同时执行多个任务。每个任务运行在不同的线程中，这些线程共享同一个进程的资源。使用多线程可以有效提高程序的执行效率，特别是在处理计算密集型或 I/O 密集型任务时。

打个比方：假设你在厨房做饭，你一个人做饭（单线程）可能需要准备、洗菜、炒菜，然后等米饭煮好才能吃。如果你能请到助手（多线程），一个人洗菜，一个人炒菜，这样两件事情可以同时进行，效率自然会大大提高。

多线程的好处
提高效率：让多个任务并行执行，减少等待时间。
增强用户体验：如在游戏或应用中，可以将耗时操作（比如加载资源）放在后台执行，避免界面卡顿。
多核 CPU 的利用：现代计算机通常是多核的，使用多线程可以充分利用多个 CPU 核心并发执行任务。

二、C++ 中的多线程支持

C++ 在 C++11 标准中引入了 std::thread 类，极大简化了多线程编程。我们可以通过 std::thread 来创建、管理线程，并通过锁机制解决线程之间的数据竞争问题。

基本的多线程示例
让我们从一个最基本的例子开始，创建一个新线程并在其中执行一段代码。

#include <iostream>
#include <thread>

// 定义一个简单的函数
void printMessage() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    // 创建并启动线程，执行 printMessage 函数
    std::thread t(printMessage);

    // 主线程等待子线程执行完毕
    t.join();

    return 0;
}

代码解释：
std::thread t(printMessage);：创建一个新线程并执行 printMessage 函数。
t.join();：主线程等待子线程执行完毕后再继续。注意：如果不调用 join()，主线程可能会提前结束，从而导致子线程无法正确执行。

传递参数给线程
线程不仅可以执行不带参数的函数，还可以传递参数。在 C++ 中，你可以通过简单的值传递或引用传递的方式，向线程函数传递参数。

#include <iostream>
#include <thread>

void printNumber(int n) {
    std::cout << "Number from thread: " << n << std::endl;
}

int main() {
    int number = 5;
    std::thread t(printNumber, number);

    t.join();
    return 0;
}

代码解释：
std::thread t(printNumber, number);：将 number 传递给线程执行的函数 printNumber。

使用 Lambda 表达式创建线程
有时候，为了简单和灵活，可以使用 Lambda 表达式来直接定义一个线程执行的任务。Lambda 表达式可以捕获外部变量，方便多线程编程。

#include <iostream>
#include <thread>

int main() {
    int value = 10;

    // 使用 Lambda 表达式创建线程
    std::thread t([value]() {
        std::cout << "Lambda thread value: " << value << std::endl;
    });

    t.join();
    return 0;
}

代码解释：
std::thread t(value { … });：通过 Lambda 表达式直接在创建线程时定义线程要执行的任务。

多线程中的共享数据与同步
多个线程可以共享同一块数据，但这可能导致数据竞争（多个线程同时修改同一个数据导致错误）。为了解决这个问题，我们需要使用**互斥量（mutex）**来保护共享资源。

数据竞争示例（错误示范）：

#include <iostream>
#include <thread>

int counter = 0;  // 共享数据

void increment(int n) {
    for (int i = 0; i < n; ++i) {
        ++counter;  // 每个线程同时修改 counter，可能引发数据竞争
    }
}

int main() {
    std::thread t1(increment, 1000);
    std::thread t2(increment, 1000);

    t1.join();
    t2.join();

    std::cout << "Final counter value: " << counter << std::endl;  // 结果可能不正确
    return 0;
}

使用互斥量解决数据竞争：

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

int counter = 0;  // 共享数据
std::mutex mtx;   // 互斥量

void increment(int n) {
    for (int i = 0; i < n; ++i) {
        std::lock_guard<std::mutex> lock(mtx);  // 加锁，保护共享数据
        ++counter;
    }
}

int main() {
    std::thread t1(increment, 1000);
    std::thread t2(increment, 1000);

    t1.join();
    t2.join();

    std::cout << "Final counter value: " << counter << std::endl;
    return 0;
}

代码解释：
std::mutex mtx;：声明一个互斥量，用来保护共享数据。
std::lock_guardstd::mutex lock(mtx);：确保在操作共享数据时，其他线程无法同时访问该数据。

线程池的概念
线程池是一种优化多线程程序性能的方式。通过提前创建一组线程并不断复用它们，可以避免频繁地创建和销毁线程，进而提高性能。

尽管 C++ 标准库中没有直接提供线程池的实现，但我们可以自己实现一个简单的线程池。

#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>

// 线程池类，用于管理一组线程并执行任务
class ThreadPool {
public:
    // 构造函数，创建指定数量的线程
    ThreadPool(size_t numThreads);
    // 析构函数，确保线程池在销毁时正确停止所有线程
    ~ThreadPool();

    // 将任务添加到任务队列中
    void enqueue(std::function<void()> task);

private:
    // 工作线程列表
    std::vector<std::thread> workers;
    // 任务队列，存储要执行的任务
    std::queue<std::function<void()>> tasks;
    // 互斥量，用于保护任务队列的访问
    std::mutex queueMutex;
    // 条件变量，用于线程等待任务
    std::condition_variable condition;
    // 标志位，指示线程池是否停止
    bool stop;

    // 工作线程执行的函数
    void workerThread();
};

// 构造函数，创建 numThreads 个线程并启动
ThreadPool::ThreadPool(size_t numThreads) : stop(false) {
    // 启动每个线程，执行 workerThread 函数
    for (size_t i = 0; i < numThreads; ++i) {
        workers.emplace_back([this] { workerThread(); });
    }
}

// 析构函数，等待所有线程执行完毕后销毁
ThreadPool::~ThreadPool() {
    {
        // 获取互斥锁，设置停止标志位
        std::unique_lock<std::mutex> lock(queueMutex);
        stop = true;
    }
    // 通知所有等待的线程
    condition.notify_all();
    // 等待每个线程完成并加入到主线程中
    for (std::thread &worker : workers) {
        worker.join();
    }
}

// 将新任务添加到任务队列中
void ThreadPool::enqueue(std::function<void()> task) {
    {
        // 获取互斥锁，保证任务队列操作的线程安全
        std::unique_lock<std::mutex> lock(queueMutex);
        // 将任务添加到队列中
        tasks.push(task);
    }
    // 通知一个等待的线程去执行新添加的任务
    condition.notify_one();
}

// 工作线程执行的函数
void ThreadPool::workerThread() {
    while (true) {
        std::function<void()> task;
        {
            // 获取互斥锁，安全访问任务队列
            std::unique_lock<std::mutex> lock(queueMutex);
            // 等待，直到有任务或线程池被停止
            condition.wait(lock, [this] { return stop || !tasks.empty(); });
            // 如果线程池停止且任务队列为空，则退出线程
            if (stop && tasks.empty()) {
                return;
            }
            // 从任务队列中取出任务
            task = std::move(tasks.front());
            tasks.pop();
        }
        // 执行任务
        task();
    }
}

// 主函数，创建线程池并提交任务
int main() {
    ThreadPool pool(4);  // 创建一个有 4 个线程的线程池

    // 添加 8 个任务到线程池
    for (int i = 0; i < 8; ++i) {
        pool.enqueue([i] {
            std::cout << "Task " << i << " is being processed" << std::endl;
        });
    }

    // 主线程休眠 2 秒，等待任务执行完成
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 0;
}

代码解释：
线程池在初始化时创建了一组线程。
enqueue() 方法将任务添加到任务队列中，线程池中的线程会从队列中取出任务并执行。
线程池的好处在于减少了频繁创建和销毁线程的开销，提升了并发执行效率。