c++多线程编程

最新推荐文章于 2025-04-27 22:34:09 发布

你一身傲骨怎能输

最新推荐文章于 2025-04-27 22:34:09 发布

阅读量838

点赞数 19

分类专栏： c++ 文章标签： c++ 开发语言 c++多线程编程

本文链接：https://blog.youkuaiyun.com/qq_33060405/article/details/144279891

版权

c++ 专栏收录该内容

58 篇文章

订阅专栏

C++ 多线程编程是指在 C++ 中使用多线程技术来实现并发执行的程序。C++11 引入了标准库中的多线程支持，使得编写多线程程序变得更加简单和安全。以下是 C++ 多线程编程的基本概念、常用工具和示例。

1. 基本概念

线程：线程是程序执行的基本单位，多个线程可以并发执行同一程序的不同部分。
并发与并行：并发是指多个线程在同一时间段内交替执行，而并行是指多个线程在同一时刻同时执行（通常在多核处理器上）。

2. C++11 多线程库

C++11 引入了 <thread> 头文件，提供了多线程编程的基本支持。以下是一些重要的类和函数：

std::thread：用于创建和管理线程。
std::mutex：用于保护共享资源，避免数据竞争。
std::lock_guard：用于自动管理互斥锁的生命周期。
std::condition_variable：用于线程间的同步。
std::future 和 std::promise：用于异步操作和结果传递。

3. 创建和管理线程

使用 std::thread 创建线程的基本步骤如下：

#include <iostream>
#include <thread>

void threadFunction(int id) {
    std::cout << "Thread " << id << " is running.\n";
}

int main() {
    std::thread t1(threadFunction, 1); // 创建线程 t1
    std::thread t2(threadFunction, 2); // 创建线程 t2

    t1.join(); // 等待线程 t1 完成
    t2.join(); // 等待线程 t2 完成

    return 0;
}

4. 互斥量和数据竞争

在多线程环境中，多个线程可能会同时访问共享资源，导致数据竞争。使用 std::mutex 来保护共享资源：

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

std::mutex mtx; // 互斥量
int sharedResource = 0;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 自动加锁
        ++sharedResource; // 访问共享资源
    }
}

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

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

    std::cout << "Final value: " << sharedResource << std::endl; // 应该是 2000
    return 0;
}

5. 条件变量

条件变量用于线程间的同步，允许一个线程等待某个条件的发生：

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

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

void waitForSignal() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; }); // 等待条件变量
    std::cout << "Thread is running after signal.\n";
}

void sendSignal() {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟一些工作
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true; // 设置条件
    }
    cv.notify_one(); // 发送信号
}

int main() {
    std::thread t1(waitForSignal);
    std::thread t2(sendSignal);

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

    return 0;
}

6. 异步操作

使用 std::async 和 std::future 可以实现异步操作：

#include <iostream>
#include <future>
#include <chrono>

int asyncFunction() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟长时间运行的任务
    return 42;
}

int main() {
    std::future<int> result = std::async(std::launch::async, asyncFunction); // 异步调用

    std::cout << "Doing other work...\n";
    std::cout << "Result: " << result.get() << std::endl; // 获取结果，阻塞直到完成

    return 0;
}

7. 总结

C++ 的多线程编程提供了强大的工具来实现并发执行。通过使用 std::thread、std::mutex、std::condition_variable 和 std::future 等类，开发者可以有效地管理线程、保护共享资源和实现异步操作。

当然可以！在 C++ 多线程编程中，还有许多重要的概念和技术可以深入探讨。以下是一些更高级的主题和最佳实践，帮助你更好地理解和使用 C++ 的多线程功能。

8. 线程安全

线程安全是指在多线程环境中，多个线程可以安全地访问共享资源而不会导致数据不一致或程序崩溃。确保线程安全的常用方法包括：

互斥量（Mutex）：使用 std::mutex 来保护共享资源，确保同一时间只有一个线程可以访问该资源。
读写锁（Shared Mutex）：使用 std::shared_mutex 允许多个线程同时读取，但在写入时会独占访问。

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>

std::shared_mutex rw_mutex;
std::vector<int> shared_data;

void readData() {
    std::shared_lock<std::shared_mutex> lock(rw_mutex); // 共享锁
    for (const auto& item : shared_data) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
}

void writeData(int value) {
    std::unique_lock<std::shared_mutex> lock(rw_mutex); // 独占锁
    shared_data.push_back(value);
}

int main() {
    std::thread writer1(writeData, 1);
    std::thread writer2(writeData, 2);
    std::thread reader(readData);

    writer1.join();
    writer2.join();
    reader.join();

    return 0;
}

9. 死锁

死锁是指两个或多个线程在等待对方释放资源，导致所有线程都无法继续执行。避免死锁的策略包括：

资源排序：确保所有线程以相同的顺序请求资源。
使用超时：在请求锁时设置超时，如果无法获得锁，则放弃。

10. 线程池

线程池是一种管理多个线程的技术，可以提高性能并减少线程创建和销毁的开销。C++ 标准库没有直接提供线程池，但可以通过自定义实现或使用第三方库（如 Boost）来实现。

以下是一个简单的线程池示例：

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

class ThreadPool {
public:
    ThreadPool(size_t threads);
    template<class F>
    auto enqueue(F&& f) -> std::future<typename std::result_of<F()>::type>;

    ~ThreadPool();

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;

    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

ThreadPool::ThreadPool(size_t threads) : stop(false) {
    for (size_t i = 0; i < threads; ++i) {
        workers.emplace_back([this] {
            for (;;) {
                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>
auto ThreadPool::enqueue(F&& f) -> std::future<typename std::result_of<F()>::type> {
    using return_type = typename std::result_of<F()>::type;

    auto task = std::make_shared<std::packaged_task<return_type()>>(std::forward<F>(f));
    std::future<return_type> res = task->get_future();
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        tasks.emplace([task]() { (*task)(); });
    }
    condition.notify_one();
    return res;
}

ThreadPool::~ThreadPool() {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for (std::thread &worker : workers) {
        worker.join();
    }
}

int main() {
    ThreadPool pool(4); // 创建一个包含 4 个线程的线程池

    for (int i = 0; i < 8; ++i) {
        pool.enqueue([i] {
            std::cout << "Task " << i << " is running on thread " << std::this_thread::get_id() << std::endl;
        });
    }

    return 0;
}

11. 使用原子操作

C++11 引入了原子类型（std::atomic），可以在多线程环境中安全地进行简单的读写操作，而无需使用互斥量。这对于性能敏感的应用程序非常有用。

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        ++counter; // 原子操作
    }
}

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

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

    std::cout << "Final counter value: " << counter.load() << std::endl; // 应该是 2000
    return 0;
}

12. 总结与最佳实践

避免共享状态：尽量减少线程间的共享状态，使用消息传递或其他并发设计模式。
使用 RAII：利用资源获取即初始化（RAII）原则，确保资源的正确管理（如使用 std::lock_guard）。
调试工具：使用工具（如 Valgrind、ThreadSanitizer）来检测数据竞争和死锁。
文档和注释：在多线程代码中，清晰的文档和注释可以帮助其他开发者理解并发逻辑。

C++ 的多线程编程是一个复杂但强大的工具，掌握这些概念和技术可以帮助你编写高效、可靠的并发程序。

当然可以！在 C++ 多线程编程中，还有许多更深入的主题和技术可以探讨。以下是一些高级主题、常见问题及其解决方案，以及一些最佳实践。

13. 线程局部存储（Thread Local Storage）

线程局部存储（TLS）允许每个线程拥有自己的变量副本，而不是共享同一个变量。这在需要为每个线程维护独立状态时非常有用。C++11 引入了 thread_local 关键字来实现这一点。

#include <iostream>
#include <thread>

thread_local int threadLocalVar = 0; // 每个线程都有自己的副本

void increment() {
    for (int i = 0; i < 5; ++i) {
        ++threadLocalVar;
        std::cout << "Thread " << std::this_thread::get_id() << " - threadLocalVar: " << threadLocalVar << std::endl;
    }
}

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

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

    return 0;
}

14. 使用 `std::atomic` 的高级特性

除了基本的原子操作，std::atomic 还提供了多种原子类型和操作，例如原子指针、原子布尔值等。它们可以用于实现无锁数据结构。

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<bool> ready(false);
std::atomic<int> data(0);

void producer() {
    data = 42; // 设置数据
    ready = true; // 设置准备状态
}

void consumer() {
    while (!ready) { // 等待数据准备好
        std::this_thread::yield(); // 让出 CPU
    }
    std::cout << "Data: " << data.load() << std::endl; // 读取数据
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);

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

    return 0;
}

15. 使用 `std::future` 和 `std::promise` 进行异步编程

std::future 和 std::promise 提供了一种机制，可以在一个线程中设置值，并在另一个线程中获取该值。这对于异步编程非常有用。

#include <iostream>
#include <thread>
#include <future>

void calculate(std::promise<int>&& prom) {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟计算
    prom.set_value(42); // 设置结果
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future(); // 获取 future

    std::thread t(calculate, std::move(prom));

    std::cout << "Waiting for result...\n";
    std::cout << "Result: " << fut.get() << std::endl; // 等待结果

    t.join();
    return 0;
}

16. 使用 `std::condition_variable` 进行线程同步

条件变量用于在某个条件满足时通知一个或多个线程。它们通常与互斥量一起使用，以确保在检查条件时不会发生数据竞争。

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

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

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; }); // 等待条件
    std::cout << "Worker thread is running.\n";
}

void signal() {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟工作
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true; // 设置条件
    }
    cv.notify_one(); // 通知一个等待的线程
}

int main() {
    std::thread t1(worker);
    std::thread t2(signal);

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

    return 0;
}