C++多线程编程基础与实践一、引言随着多核处理器的普及，多线程编程成为提升程序性能和响应能力的重要手段。C++11 标

一、引言

随着多核处理器的普及，多线程编程成为提升程序性能和响应能力的重要手段。C++11 标准引入了线程库，提供了跨平台的多线程支持，使得多线程编程更加规范和便利。

本文将系统介绍 C++ 多线程的基础知识、线程管理、同步机制及常见实战案例，帮助你掌握现代 C++ 多线程编程技巧。

二、多线程基础

1. 线程的概念

线程是操作系统调度的最小执行单元，多个线程共享进程的内存空间。合理使用多线程可以实现并行计算和异步任务。

2. C++11 线程支持

C++11 标准库提供了 <thread> 头文件，实现线程创建和管理。

三、线程的创建与管理

1. 创建线程

cpp复制编辑#include <iostream>
#include <thread>

void threadFunc() {
    std::cout << "子线程执行" << std::endl;
}

int main() {
    std::thread t(threadFunc);
    t.join();  // 等待子线程完成
    return 0;
}

2. 传递参数

cpp复制编辑void printNum(int n) {
    std::cout << "数字: " << n << std::endl;
}

int main() {
    std::thread t(printNum, 10);
    t.join();
}

3. 线程分离

cpp复制编辑std::thread t(threadFunc);
t.detach(); // 线程独立运行，主线程不等待

四、线程同步机制

多线程访问共享资源时，需保证数据一致性和防止竞态条件。

1. 互斥锁 std::mutex

cpp复制编辑#include <mutex>

std::mutex mtx;
int count = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++count;
}

2. 读写锁和递归锁（C++17引入）

3. 条件变量 std::condition_variable

用于线程间通知与等待。

cpp复制编辑#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void waitThread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });
    std::cout << "收到通知，继续执行" << std::endl;
}

void notifyThread() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();
}

五、线程间通信和同步案例

实现生产者-消费者模型：

cpp复制编辑#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>

std::queue<int> q;
std::mutex mtx;
std::condition_variable cv;
bool finished = false;

void producer() {
    for (int i = 0; i < 10; ++i) {
        {
            std::lock_guard<std::mutex> lock(mtx);
            q.push(i);
            std::cout << "生产: " << i << std::endl;
        }
        cv.notify_one();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    {
        std::lock_guard<std::mutex> lock(mtx);
        finished = true;
    }
    cv.notify_all();
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !q.empty() || finished; });
        if (!q.empty()) {
            int val = q.front();
            q.pop();
            lock.unlock();
            std::cout << "消费: " << val << std::endl;
        } else if (finished) {
            break;
        }
    }
}

int main() {
    std::thread p(producer);
    std::thread c(consumer);
    p.join();
    c.join();
    return 0;
}