当前位置：首页 > news >正文

C++：std::thread、条件变量与信号量

news 来源：原创 2025/5/9 11:02:08

介绍

在多线程编程的世界里，协调不同线程之间的工作是一项极具挑战性的任务。线程可能需要等待特定条件的满足，或者对共享资源的访问进行限制。C++ 标准库为我们提供了强大的工具，如 std::thread 用于创建和管理线程，条件变量用于线程间的同步，信号量则用于控制对资源的访问。本文将通过具体的 C++ 代码示例，详细介绍如何使用这些工具。

std::thread 基础

std::thread 是 C++11 引入的用于创建和管理线程的类。它允许我们轻松地在程序中创建新的执行线程。下面是一个简单的 std::thread

#include <iostream>
#include <thread>

void printMessage(const std::string& message) {
    std::cout << "Thread says: " << message << std::endl;
}

int main() {
    std::thread t(printMessage, "Hello, World!");
    t.join();
    return 0;
}

定义了一个函数 printMessage，然后使用 std::thread 创建了一个新线程，并将 printMessage 函数作为线程的入口点，同时传递了一个字符串参数。join() 方法用于等待线程执行完毕。

条件变量

条件变量是一种同步原语，用于线程之间的通信和协调。它允许一个线程等待某个条件的满足，而另一个线程可以在条件满足时通知等待的线程。
生产者 - 消费者模型示例
生产者 - 消费者模型是多线程编程中常见的模式，生产者线程负责生产数据，消费者线程负责消费数据。我们可以使用条件变量来实现线程间的同步。

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

std::queue<int> dataQueue;
std::mutex mtx;
std::condition_variable cv;
bool isProducing = true;

// 生产者线程函数
void producer() {
    for (int i = 0; i < 5; ++i) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        {
            std::unique_lock<std::mutex> lock(mtx);
            dataQueue.push(i);
            std::cout << "Produced: " << i << std::endl;
        }
        cv.notify_one();
    }
    {
        std::unique_lock<std::mutex> lock(mtx);
        isProducing = false;
    }
    cv.notify_one();
}

//消费者线程函数
void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return!dataQueue.empty() ||!isProducing; });
        if (!dataQueue.empty()) {
            int value = dataQueue.front();
            dataQueue.pop();
            std::cout << "Consumed: " << value << std::endl;
        } else if (!isProducing) {
            break;
        }
    }
}

int main() {
    std::thread producerThread(producer);
    std::thread consumerThread(consumer);

    producerThread.join();
    consumerThread.join();

    return 0;
}

std::queue dataQueue：用于存储生产者生产的数据。
std::mutex mtx：用于保护对 dataQueue 的访问，确保线程安全。
std::condition_variable cv：用于线程间的同步。
producer() 函数：生产者线程每隔 1 秒生产一个数据，并将其加入队列。生产完成后，通知消费者线程。
consumer() 函数：消费者线程等待条件变量的通知，当队列中有数据时，从队列中取出数据进行消费。
cv.wait(lock, [] { return!dataQueue.empty() ||!isProducing; })：消费者线程等待，直到队列非空或者生产结束。

信号量

信号量是一种用于控制对资源访问的同步原语。在 C++ 标准库中，并没有直接提供信号量的实现，可以使用 std::mutex 和 std::condition_variable 来模拟信号量。
信号量的实现

#include <mutex>
#include <condition_variable>

class Semaphore {
public:
    Semaphore(int count = 0) : count_(count) {}

    void notify() {
        std::unique_lock<std::mutex> lock(mtx_);
        ++count_;
        cv_.notify_one();
    }

    void wait() {
        std::unique_lock<std::mutex> lock(mtx_);
        cv_.wait(lock, [this] { return count_ > 0; });
        --count_;
    }

private:
    int count_;
    std::mutex mtx_;
    std::condition_variable cv_;
};

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

Semaphore sem(2); // 允许最多 2 个线程同时访问资源

void accessResource(int id) {
    sem.wait();
    std::cout << "Thread " << id << " is accessing the resource." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "Thread " << id << " has finished accessing the resource." << std::endl;
    sem.notify();
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(accessResource, i);
    }

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

Semaphore 类：实现了一个简单的信号量。notify() 方法用于增加信号量的值并通知等待的线程，wait() 方法用于等待信号量的值大于 0 并减少信号量的值。
accessResource() 函数：线程在访问资源前调用 sem.wait() 等待信号量，访问完成后调用 sem.notify() 释放信号量。
emplace_back 是 C++ 标准库容器（如 std::vector、std::deque 等）提供的一个成员函数，它主要用于在容器的尾部直接构造一个新元素。