C++中的多线程编程入门与实践一、引言随着现代计算机硬件多核趋势，多线程编程成为提升程序性能的重要手段。C++11标准

一、引言

随着现代计算机硬件多核趋势，多线程编程成为提升程序性能的重要手段。C++11标准引入了多线程支持，使得C++程序员可以方便地使用线程、互斥量和条件变量等工具来实现并发程序。

本文将介绍C++多线程编程的基本概念、线程的创建与管理、线程同步机制，并通过示例帮助你掌握实战技巧。

二、多线程基础概念

线程（Thread）：操作系统调度的最小执行单元，多个线程可并行执行。
进程（Process）：操作系统分配资源的独立单位，包含至少一个线程。
并发与并行：并发指多个任务交替执行，并行指多个任务同时执行。

三、线程创建与管理

1. 使用std::thread

C++11通过<thread>头文件提供了std::thread类，支持线程的创建和管理。

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

void func() {
    std::cout << "线程函数执行\n";
}

int main() {
    std::thread t(func);  // 创建线程
    t.join();             // 等待线程结束
    return 0;
}

2. 线程参数传递

cpp复制编辑void print_num(int n) {
    std::cout << "线程参数：" << n << std::endl;
}

std::thread t(print_num, 42);

四、线程同步机制

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

1. 互斥量（std::mutex）

cpp复制编辑#include <mutex>

std::mutex mtx;

void safe_print(int id) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "线程 " << id << " 打印\n";
}

std::lock_guard保证异常安全，自动释放锁。

2. 条件变量（std::condition_variable）

实现线程间的等待和通知机制。

cpp复制编辑#include <condition_variable>
#include <mutex>

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

void wait_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });
    std::cout << "线程被唤醒\n";
}

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

五、线程安全的数据结构示例

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

template <typename T>
class ThreadSafeQueue {
private:
    std::queue<T> queue_;
    std::mutex mutex_;
    std::condition_variable cv_;

public:
    void push(T value) {
        {
            std::lock_guard<std::mutex> lock(mutex_);
            queue_.push(std::move(value));
        }
        cv_.notify_one();
    }

    T wait_and_pop() {
        std::unique_lock<std::mutex> lock(mutex_);
        cv_.wait(lock, [this]{ return !queue_.empty(); });
        T value = std::move(queue_.front());
        queue_.pop();
        return value;
    }
};

六、线程管理注意事项

线程结束必须调用join()或detach()避免程序异常。
避免死锁：保持加锁顺序一致，尽量减少锁粒度。
使用RAII封装锁，防止忘记释放。

七、实战案例：多线程下载模拟

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

void download_task(int id) {
    std::cout << "线程 " << id << " 开始下载\n";
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "线程 " << id << " 下载完成\n";
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(download_task, i);
    }
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}