std::condition_variable理解

原创 已于 2024-12-13 16:52:31 修改 · 1.1k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #c++11 #线程锁

于 2024-12-13 16:48:36 首次发布

1.概要

1.概要

std::condition_variable本质上就是当程序不满足运行条件的时候让线程停下了，而不是不断的重复运行；你可以把一个条件交给std::condition_variable，等待std::condition_variable在条件满足的时候激活你的线程，让你继续处理。

2.关联链接

2.内容

std::condition_variable 是 C++ 标准库中用于线程间同步的一种机制。它主要用于让线程在某些条件满足时进行等待或通知其他线程条件已经满足。这种机制对于实现线程间的协调、避免数据竞争以及提高程序的并发性能非常有用。

基本概念

  • 等待（Wait）：一个或多个线程可以在 std::condition_variable 上等待，直到某个特定条件被满足。等待线程会释放与 std::condition_variable 关联的互斥锁（mutex），从而允许其他线程修改数据或状态。
  • 通知（Notify）：当某个线程改变了某个条件（例如，某个共享变量的值）并且希望等待线程继续执行时，它可以通知 std::condition_variable。这种通知可以是针对单个线程（notify_one）或者所有等待线程（notify_all）。

使用方法

  1. 创建 std::condition_variable 对象：首先，你需要创建一个 std::condition_variable 对象，它通常与某个互斥锁（std::mutex）一起使用来保护共享数据。

  2. 等待线程：

    • 锁定互斥锁以保护共享数据。
    • 使用 wait 方法等待条件变量。wait 方法会原子地解锁互斥锁并使线程等待条件变量被通知。当条件变量被通知且线程重新获得互斥锁后，wait 方法返回。

  3. 通知线程：

    • 在适当的时候（例如，当某个条件被满足时），使用 notify_one 或 notify_all 方法通知等待线程。

示例代码

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

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

void print_id(int id) {
    std::unique_lock<std::mutex> lck(mtx);
    while (!ready) cv.wait(lck);
    // 当 ready 为 true 时，继续执行
    std::cout << "Thread " << id << '\n';
}

void go() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;
    cv.notify_all();  // 通知所有等待线程
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(print_id, i);

    std::cout << "10 threads ready to race...\n";
    go();  // 改变条件并通知所有线程

    for (auto& th : threads) th.join();

    return 0;
}

在这个例子中，10个线程都在等待 ready 变量变为 true。主线程通过调用 go 函数改变 ready 的值，并使用 notify_all 通知所有等待线程继续执行。这样，所有线程都会打印出自己的 ID。

注意事项

  • 避免虚假唤醒（Spurious Wakeups）：在实际使用中，即使条件变量被通知，也应该在 wait 的循环中检查条件，因为可能存在虚假唤醒的情况。
  • 性能考虑：条件变量通常与互斥锁一起使用，因此在使用时应该注意互斥锁的性能开销。
  • 避免死锁：确保在等待条件变量之前已经锁定了互斥锁，并且在修改条件之后及时通知等待线程。

3.关联知识

1.std::condition_variable的Wait函数等待的互斥锁，可以多个对象等待一个互斥锁吗

在C++中，std::condition_variable的wait函数确实需要与一个互斥锁（std::mutex）配合使用，以保护共享数据和确保线程安全。关于多个对象等待一个互斥锁的问题，这里有几个关键点需要澄清：

  1. 互斥锁的所有权：在任何时刻，只有一个线程可以拥有互斥锁的所有权。当线程调用wait函数时，它会首先释放互斥锁的所有权，并进入等待状态，直到被通知条件已经满足。一旦条件满足并被唤醒，线程会重新尝试获取互斥锁的所有权，以便安全地访问共享数据。

  2. 多个线程等待：是的，多个线程可以同时等待同一个std::condition_variable，但它们都会释放各自持有的互斥锁（如果有的话）在进入等待状态之前。当条件变量被通知（通过notify_one或notify_all）时，这些等待线程中的一个或多个将被唤醒，并尝试重新获取互斥锁。

  3. 互斥锁与条件变量的关系：互斥锁用于保护共享数据，确保在修改这些数据时不会发生数据竞争。条件变量则用于同步线程之间的执行顺序，让线程在特定条件下等待或继续执行。它们通常一起使用，但互斥锁和条件变量本身是独立的对象。

  4. 等待多个条件：如果线程需要等待多个条件同时满足，可能需要使用更复杂的同步机制，如std::condition_variable_any，它允许与不同类型的锁一起使用，或者通过组合多个条件变量和互斥锁来实现。

  5. 避免死锁：在使用互斥锁和条件变量时，必须小心避免死锁。例如，确保在调用wait之前已经锁定了互斥锁，确保在通知条件变量之后没有其他线程会无限期地持有互斥锁等。

综上所述，多个线程确实可以同时等待同一个互斥锁（在调用wait时释放它），但它们会按照互斥锁的规则来依次获取锁的所有权，并确保在访问共享数据时不会发生数据竞争。

2.只有在拥有互斥锁的所有权后，才可以执行std::condition_variable的wait函数和这个互斥锁绑定，对吗 

是的，您的理解是正确的。在C++中，std::condition_variable的wait函数必须与一个互斥锁（std::mutex）结合使用，而且确实需要在线程拥有该互斥锁的所有权之后才能调用wait函数。

这里是具体的步骤和逻辑：

  1. 锁定互斥锁：首先，线程需要锁定与条件变量相关联的互斥锁。这通常是通过创建一个std::unique_lock<std::mutex>对象来完成的，该对象在构造时会自动锁定互斥锁。

  2. 调用wait函数：拥有互斥锁之后，线程可以调用std::condition_variable的wait函数。调用wait时，会发生以下事情：

    • wait函数会原子地释放互斥锁的所有权，并使线程进入等待状态。
    • 当条件变量被其他线程通知（通过notify_one或notify_all）时，等待线程会被唤醒。
    • 被唤醒的线程会尝试重新获取互斥锁的所有权。一旦获取成功，wait函数返回，线程可以继续执行。

  3. 检查条件：通常，wait函数会在一个循环中被调用，因为即使线程被唤醒，也不一定意味着它等待的条件已经满足（可能是由于虚假唤醒或其他原因）。因此，线程在wait返回后应该检查条件是否真的满足。

  4. 处理共享数据：如果条件满足，线程可以安全地处理受互斥锁保护的共享数据，因为它现在拥有互斥锁的所有权。

  5. 解锁互斥锁：当线程完成对共享数据的处理并准备退出临界区时，它会释放互斥锁的所有权（这通常是通过std::unique_lock对象的析构函数自动完成的）。

因此，确实只有在线程拥有互斥锁的所有权之后，才能执行std::condition_variable的wait函数，并将这个互斥锁与wait函数绑定。这是确保线程安全访问共享数据和正确同步线程执行顺序的关键步骤。

3.std::condition_variable的wait函数执行后，所在的线程就会停止，直到收到notify_all或者notify_one的通知为止对吗 

是的，您的理解基本正确，但有一些细节需要澄清。

当线程调用std::condition_variable的wait函数时，它确实会进入一种等待状态，释放与条件变量相关联的互斥锁，并等待其他线程通过调用notify_one或notify_all来唤醒它。然而，有几点需要注意：

  1. 等待状态与阻塞：线程进入等待状态并不意味着它完全停止执行。在底层，操作系统可能会将线程置于一种低功耗的等待状态，或者将其从调度器中移除，直到有适当的事件（如条件变量的通知）发生。但从高层编程的角度来看，我们可以认为线程在wait调用处“阻塞”了。

  2. 虚假唤醒：有时候，即使没有其他线程调用notify_one或notify_all，等待线程也可能被唤醒。这被称为“虚假唤醒”（spurious wakeup）。因此，通常的做法是在wait函数返回的循环中检查条件是否真的满足，而不是仅仅依赖wait的返回。

  3. 通知机制：当其他线程调用notify_one时，会唤醒一个正在等待该条件变量的线程（如果有的话）。如果调用notify_all，则会唤醒所有等待该条件变量的线程。被唤醒的线程会重新尝试获取与条件变量相关联的互斥锁，以便安全地访问共享数据。

  4. 超时等待：std::condition_variable的wait_for或wait_until函数允许线程等待一个指定的时间段或直到某个时间点。如果在超时之前没有收到通知，线程会自动被唤醒，并可以继续执行后续的代码。

综上所述，当线程调用std::condition_variable的wait函数时，它会进入等待状态，直到其他线程通过调用notify_one或notify_all来唤醒它，或者在某些情况下（如使用超时等待时）超时自动唤醒。然而，由于存在虚假唤醒的可能性，线程通常需要在wait返回的循环中检查条件是否真的满足。

4.std::condition_variable的接口 

std::condition_variable 是 C++ 标准库中的一个同步原语，用于线程间的条件等待和通知。它提供了几个关键的接口函数，允许线程在特定条件下等待，直到其他线程通知条件已经满足。以下是 std::condition_variable 的主要接口：

  1. 构造函数和析构函数：

    • condition_variable(): 默认构造函数，创建一个新的条件变量。
    • ~condition_variable(): 析构函数，销毁条件变量。注意，析构函数不应该在还有线程等待该条件变量时被调用。

  2. 等待函数：

    • void wait(std::unique_lock<std::mutex>& lock): 使当前线程等待条件变量。调用此函数时，线程会释放 lock 参数所表示的互斥锁，并阻塞当前线程，直到其他线程调用 notify_one 或 notify_all 唤醒它。在被唤醒后，线程会重新尝试获取互斥锁。
    • 模板函数 wait_for 和 wait_until：这两个函数允许线程等待一个指定的时间段或直到某个时间点。它们也接受一个 std::unique_lock<std::mutex> 参数，并在等待期间释放锁。
      • template <class Rep, class Period> bool wait_for(std::unique_lock<std::mutex>& lock, const std::chrono::duration<Rep, Period>& rel_time): 等待指定的时间段。
      • template <class Clock, class Duration> bool wait_until(std::unique_lock<std::mutex>& lock, const std::chrono::time_point<Clock, Duration>& abs_time): 等待直到指定的时间点。

    这两个函数都会返回一个布尔值，指示等待是否因为超时而结束（false）还是因为被通知而结束（true）。

  3. 通知函数：

    • void notify_one(): 唤醒一个正在等待该条件变量的线程（如果有的话）。
    • void notify_all(): 唤醒所有正在等待该条件变量的线程。

使用 std::condition_variable 时，通常遵循以下模式：

  • 线程 A（或多个线程）在条件不满足时调用 wait 函数，并释放与条件变量相关联的互斥锁。
  • 线程 B（或其他线程）在条件满足时调用 notify_one 或 notify_all 函数来唤醒等待的线程。
  • 被唤醒的线程重新获取互斥锁，并检查条件是否真的满足（因为可能存在虚假唤醒）。

需要注意的是，std::condition_variable 本身并不管理互斥锁；它只负责等待和通知。互斥锁（通常是 std::mutex）必须由调用者管理，并在调用 wait 函数之前被锁定。此外，为了避免死锁和竞态条件，应该仔细设计条件变量的使用，并确保所有访问共享数据的线程都正确地使用互斥锁和条件变量。

5.wait有几种重载，请分别举例 

std::condition_variable 的 wait 函数有几种重载形式，主要根据是否接受谓词（predicate）参数以及等待的时间类型来区分。以下是这些重载形式及其示例：

1. 不带谓词的等待函数

wait(std::unique_lockstd::mutex& lock)

这个函数使当前线程等待条件变量，直到另一个线程调用 notify_one 或 notify_all 来唤醒它。在等待期间，线程会释放传入的 std::unique_lock<std::mutex> 所代表的互斥锁。

示例：

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

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock);  // 等待直到被notify_one或notify_all唤醒
    // 当被唤醒后，继续执行后续代码
}

int main() {
    std::thread t(worker);
    // 主线程休眠一段时间或执行其他任务
    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 设置条件变量
        cv.notify_one();  // 唤醒一个等待的线程
    }

    t.join();
    return 0;
}

2. 带谓词的等待函数

wait(std::unique_lockstd::mutex& lock, Predicate pred)

这个函数使当前线程等待条件变量，直到谓词 pred 返回 true 或另一个线程调用 notify_one 或 notify_all 来唤醒它。在等待期间，线程会释放传入的 std::unique_lock<std::mutex> 所代表的互斥锁。

示例：

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

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });  // 等待直到ready为true或被唤醒
    // 当条件满足（ready为true）或被唤醒后，继续执行后续代码
}

int main() {
    std::thread t(worker);
    // 主线程休眠一段时间或执行其他任务
    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 设置条件变量
        cv.notify_one();  // 唤醒一个等待的线程
    }

    t.join();
    return 0;
}

3. 带有超时时间的等待函数

wait_for(std::unique_lockstd::mutex& lock, const std::chrono::duration<Rep, Period>& rel_time)

这个函数使当前线程等待条件变量，直到超时时间 rel_time 到期或另一个线程调用 notify_one 或 notify_all 来唤醒它。在等待期间，线程会释放传入的 std::unique_lock<std::mutex> 所代表的互斥锁。

示例：




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

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    if (cv.wait_for(lock, std::chrono::seconds(2)) == std::cv_status::timeout) {
        // 超时处理
        std::cout << "Wait timed out!" << std::endl;
    } else {
        // 被唤醒或条件满足后继续执行
    }
}

int main() {
    std::thread t(worker);
    // 主线程休眠一段时间或执行其他任务
    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 设置条件变量
        cv.notify_one();  // 唤醒一个等待的线程
    }

    t.join();
    return 0;
}
wait_for(std::unique_lockstd::mutex& lock, const std::chrono::duration<Rep, Period>& rel_time, Predicate pred)

这个函数使当前线程等待条件变量，直到谓词 pred 返回 true、超时时间 rel_time 到期或另一个线程调用 notify_one 或 notify_all 来唤醒它。在等待期间，线程会释放传入的 std::unique_lock<std::mutex> 所代表的互斥锁。

示例：




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

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    if (cv.wait_for(lock, std::chrono::seconds(2), []{ return ready; }) == std::cv_status::timeout) {
        // 超时处理
        std::cout << "Wait timed out!" << std::endl;
    } else {
        // 被唤醒或条件满足后继续执行
    }
}

int main() {
    std::thread t(worker);
    // 主线程休眠一段时间或执行其他任务
    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 设置条件变量
        cv.notify_one();  // 唤醒一个等待的线程
    }

    t.join();
    return 0;
}

4. 带有绝对时间点的等待函数

wait_until(std::unique_lockstd::mutex& lock, const std::chrono::time_point<Clock, Duration>& abs_time)

这个函数使当前线程等待条件变量，直到指定的绝对时间点 abs_time 到期或另一个线程调用 notify_one 或 notify_all 来唤醒它。在等待期间，线程会释放传入的 std::unique_lock<std::mutex> 所代表的互斥锁。

示例：

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

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    auto timeout_time = std::chrono::steady_clock::now() + std::chrono::seconds(2);
    if (cv.wait_until(lock, timeout_time) == std::cv_status::timeout) {
        // 超时处理
        std::cout << "Wait timed out!" << std::endl;
    } else {
        // 被唤醒或条件满足后继续执行
    }
}

int main() {
    std::thread t(worker);
    // 主线程休眠一段时间或执行其他任务
    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 设置条件变量
        cv.notify_one();  // 唤醒一个等待的线程
    }

    t.join();
    return 0;
}
wait_until(std::unique_lockstd::mutex& lock, const std::chrono::time_point<Clock, Duration>& abs_time, Predicate pred)

这个函数使当前线程等待条件变量，直到谓词 pred 返回 true、指定的绝对时间点 abs_time 到期或另一个线程调用 notify_one 或 notify_all 来唤醒它。在等待期间，线程会释放传入的 std::unique_lock<std::mutex> 所代表的互斥锁。

示例：




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

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    auto timeout_time = std::chrono::steady_clock::now() + std::chrono::seconds(2);
    if (cv.wait_until(lock, timeout_time, []{ return ready; }) == std::cv_status::timeout) {
        // 超时处理
        std::cout << "Wait timed out!" << std::endl;
    } else {
        // 被唤醒或条件满足后继续执行
    }
}

int main() {
    std::thread t(worker);
    // 主线程休眠一段时间或执行其他任务
    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 设置条件变量
        cv.notify_one();  // 唤醒一个等待的线程
    }

    t.join();
    return 0;
}

 5.当std::condition_variable的Wait有多个线程绑定的时候，当notify_one()调用的时候，会是那个线程被激活呢，是按顺序的吗

在C++的多线程编程中，std::condition_variable是一个常用的同步机制，用于让线程等待某个条件的发生。当std::condition_variable的wait函数被多个线程调用时，这些线程都会进入等待状态，直到某个线程调用notify_one()或notify_all()来唤醒等待的线程。

关于你的问题，当notify_one()被调用时，哪个线程会被唤醒并不是按顺序确定的，而是由操作系统的调度策略决定的。标准库并不保证唤醒的线程会是按它们进入等待状态的顺序，也不保证是任何特定的线程。这种不确定性是多线程编程中的一个基本特性，称为“唤醒的随意性”（spurious wakeup）。

在实际应用中，如果你需要确保某种特定的顺序或者公平性，你需要在你的程序设计中加入额外的逻辑来管理这种顺序。例如，你可以使用队列来管理等待的线程，或者使用其他同步机制（如互斥锁和条件变量结合）来确保按照某种特定的顺序来处理线程。

总结一下，std::condition_variable的notify_one()唤醒哪个等待的线程是不确定的，依赖于操作系统的线程调度器。如果需要特定的唤醒顺序，你需要在程序设计中显式地管理这一点。

6.std::condition_variable的作用

std::condition_variable 是 C++ 标准库中的一个同步原语，用于线程间的通知机制。它允许一个或多个线程等待某个条件，并在条件满足时被唤醒以继续执行。std::condition_variable 通常与 std::mutex 配合使用，以确保在修改和检查条件时的原子性和避免竞态条件。

以下是 std::condition_variable 的一些关键作用和用法：

  1. 线程等待：
    • 一个或多个线程可以调用 wait 方法来等待某个条件变量。调用 wait 时，线程会被阻塞，同时释放关联的互斥锁（std::mutex），允许其他线程修改数据或状态。
  2. 通知等待线程：
    • 当某个线程改变了某个条件（例如某个共享变量的值）且希望其他等待该条件的线程继续执行时，它可以调用 notify_one 来唤醒一个等待线程，或调用 notify_all 来唤醒所有等待线程。
  3. 避免忙等待：
    • 使用 std::condition_variable 可以有效避免忙等待（busy waiting），因为线程在条件不满足时会被操作系统挂起，而不是不断地轮询检查条件是否满足。
  4. 与 std::unique_lock<std::mutex> 配合使用：
    • wait 方法需要传入一个 std::unique_lock<std::mutex> 对象，该对象管理着互斥锁的锁定和解锁。当线程被唤醒时，它会自动重新锁定互斥锁，以确保线程安全地访问共享数据。

示例代码

以下是一个简单的示例，演示了如何使用 std::condition_variable 来同步两个线程：

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

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

void print_id(int id) {
    std::unique_lock<std::mutex> lck(mtx);
    // 等待 ready 变为 true
    cv.wait(lck, [] { return ready; });

    // 被唤醒后，打印线程 ID
    std::cout << "Thread " << id << std::endl;
}

void set_ready() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;
    // 通知所有等待线程
    cv.notify_all();
}

int main() {
    std::thread threads[10];
    // 创建 10 个线程
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(print_id, i);

    std::cout << "10 threads ready to race..." << std::endl;
    set_ready(); // 改变 ready 状态并通知所有线程

    for (auto& th : threads) th.join();

    return 0;
}

在这个示例中，10 个线程在创建后会等待 ready 变量变为 true。主线程调用 set_ready 函数，将 ready 设置为 true 并调用 notify_all 唤醒所有等待的线程，之后这些线程继续执行并打印它们的 ID。

总之，std::condition_variable 是一个非常有用的工具，用于实现线程间的同步和协调，特别是在需要等待某个条件满足时。

7.std::condition_variable的原理

std::condition_variable 是 C++ 标准库中用于线程间同步的一种机制。它通常与 std::mutex 配合使用，可以让一个或多个线程等待某个条件成立，并在条件成立时被唤醒继续执行。std::condition_variable 的主要成员函数包括 wait、notify_one 和 notify_all。

原理概述

  1. 等待线程：
    • 一个或多个线程可以调用 std::condition_variable 的 wait 方法来等待某个条件成立。
    • wait 方法通常需要一个 std::unique_lock<std::mutex> 对象作为参数，该对象会在调用 wait 时被释放（解锁），从而允许其他线程获取锁并修改条件。
    • wait 方法会使调用线程进入阻塞状态，直到另一个线程调用 notify_one 或 notify_all 方法唤醒它。同时，wait 方法会在被唤醒时重新锁定互斥锁（即重新获取 std::unique_lock<std::mutex>）。
  2. 通知线程：
    • 当一个线程改变了某个条件（例如某个共享变量的值）并希望其他等待该条件的线程继续执行时，可以调用 notify_one 或 notify_all 方法。
    • notify_one 会唤醒一个正在等待该条件变量的线程（如果有多个等待线程，则唤醒其中一个）。
    • notify_all 会唤醒所有正在等待该条件变量的线程。

典型用法

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

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

void print_id(int id) {
    std::unique_lock<std::mutex> lck(mtx);
    // 等待 ready 变为 true
    cv.wait(lck, [] { return ready; });

    // 被唤醒后，打印线程 ID
    std::cout << "Thread " << id << '\n';
}

void go() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;
    // 通知所有等待线程
    cv.notify_all();
}

int main() {
    std::thread threads[10];
    // 创建 10 个线程
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(print_id, i);

    std::cout << "10 threads ready to race...\n";
    go(); // 改变条件并通知所有线程

    for (auto& th : threads) th.join();

    return 0;
}

注意事项

  1. 避免虚假唤醒：wait 方法通常与一个谓词（predicate）一起使用，该谓词是一个返回 bool 值的可调用对象（如 lambda 表达式）。wait 会在被唤醒时重新检查谓词，如果谓词返回 false（表示条件仍未满足），wait 会继续等待。这可以处理虚假唤醒（spurious wakeups）的问题。

  2. 通知时机：调用 notify_one 或 notify_all 之前，确保已经修改了条件，并且修改是在持有相关互斥锁的情况下进行的，以防止竞态条件（race condition）。

  3. 性能考虑：std::condition_variable 通常用于较长时间的等待，对于频繁检查和短时间等待的场景，可能需要考虑其他同步机制（如自旋锁）。

通过 std::condition_variable，可以实现复杂的线程间同步和通信模式，从而有效地协调多个线程的执行顺序。

 

C++多线程std::condition_variable(条件变量)
qls315的博客
07-03 826
在上篇文章C++多线程 task--std::promise和std::future_qls315的博客-优快云博客介绍了std::promise和std::future，其可以模拟一次性事件通知机制(这也是条件变量的功能之一)为了补充相应的事件通知机制相应的方式，本文继续介绍std::condition_variable(条件变量).条件变量是一种C++标准提供的同步原语，其可以用来阻塞一个或者多个线程，直到某个线程修改了共享变量(condition),并且向条件变量发送通知。执行修改共享变量的线程，必
C++11多线程之std::condition_variable条件变量
十三阿哥的博客
08-11 533
【代码】C++11多线程之std::condition_variable条件变量。
C++ std::condition_variable 条件变量知识总结
最新发布
weixin_38384271的博客
06-03 1035
条件变量(Condition Variable)
C++(14): STL条件变量std::condition_variable
tecsai的博客
04-10 4152
在C++的标准模板库（STL）中，std::condition_variable是一个非常重要的同步原语，用于在多线程编程中实现线程间的条件同步。它允许一个或多个线程等待某个条件成立，当条件成立时，等待的线程会被唤醒并继续执行。
C++11 并发指南五(std::condition_variable 详解)
weixin_34014277的博客
08-27 2343
前面三讲《C++11 并发指南二(std::thread 详解)》，《C++11 并发指南三(std::mutex 详解)》分别介绍了 std::thread，std::mutex，std::future 等相关内容，相信读者对 C++11 中的多线程编程有了一个最基本的认识，本文将介绍 C++11 标准中 &lt;condition_variable&gt; 头文件里面的类和相关函数。 &lt...
std::condition_variable
heusunduo88的博客
05-17 1万+
std::condition_variable std::condition_variable，是C++11提供的条件变量，可用于同时阻塞一个线程或多个线程。一般的，生产者线程利用支持std::mutex的std::lock_guard/std::unique_lock修改共享变量后，并通知condition_variable。消费者线程获取同一个std::mutex(std::unique_lock所持有)，并调用std::condition_variable的wait, wait_for, or wai
C++并发编程五：（std::condition_variable详解）
小罗的博客
04-09 7979
c++11多线程 条件变量 std::condition_variable 类介绍
关于 std::condition_variable
Appleeatingboy的博客
05-10 1459
std::condition_variable 是 C++ 标准库提供的一个线程同步的工具，用于实现线程间的条件变量等待和通知机制。条件变量的发生通常与某个共享变量的状态改变相关。 在多线程编程中，条件变量通常和互斥锁（std::mutex）一起使用，以避免死锁等问题。
std::scoped_lock` 和 `std::lock() ，condition_variable,promise
MrGong123的博客
01-04 1107
std::scoped_lock` 和 `std::lock() ，condition_variable,promise
【C++】std::condition_variable
Hi, Boy
05-07 601
是 C++ 并发编程中重要的同步原语之一，用于线程间的通信和同步。通过合理地使用，可以有效地实现多线程之间的协调和同步，提高程序的并发性能和可靠性。
C++条件变量--std::condition_variable
热门推荐
未来之歌
07-29 2万+
条件变量允许我们通过通知进而实现线程同步。 因此，您可以实现发送方/接收方或生产者/消费者之类的工作流。 在这样的工作流程中，接收者正在等待发送者的通知。如果接收者收到通知，它将继续工作。 std::condition_variable 条件变量可以履行发送者或接收者的角色。 作为发送者，它可以通知一个或多个接收者。 这就是使用条件变量所需要知道的基本所有内容，程序示例： /...
std::condition_variable 详解
qq_33089547的博客
04-06 1469
假设你有多个线程，其中一个线程负责产生数据（生产者），而其他线程负责消费这些数据（消费者）。当生产者产生数据时，它可能会设置一个条件变量来通知消费者线程数据已经准备好。消费者线程则会在循环中等待这个条件变量，直到数据准备好。是 C++ 标准库中的一个类，用于同步线程的执行。的成员变量），以允许线程等待某个条件成立。配合使用，以及一个条件（通常是。
C++ std::condition_variable
m0_59680769的博客
07-30 1513
是C++11引入的一个同步机制，主要用于在线程之间进行事件通知协调。它是标准库中的一个类，声明在头文件中。允许一个或多个线程等待另一个线程发送的信号（通过条件变量来实现的），从而基于某些条件进行协调动作。
C++之std::condition_variable
jzjhome的博客
06-12 396
是 C++ 标准库中用于线程间同步的类，通常与std::mutex结合使用。它提供了一种在多线程环境下等待条件变量满足的机制，以避免忙等（busy-waiting）并减少 CPU 资源的浪费。以下是。
C++同步机制之条件变量（std::condition_variable）
wxj1992的博客
05-16 8151
文章目录一、使用机制1.1 涉及的主要概念1.2 wait线程中的用法1.3 notify线程中的用法二、成员函数2.1 唤醒函数2.2 等待函数三、为什么需要互斥锁四、虚假唤醒五、示例 对多线程编程有了解的对条件变量（condition_variable）这个概念一定不陌生，相较于另一种常见的同步机制互斥锁，条件变量是一种更高层次的同步手段，互斥锁用于保护一段临界区，也就是各个线程互斥地去访问同一块资源，这是一种很简单直接的同步手段，可以cover住很大一类的同步场景，比如多线程修改一个非线程安全的uno
STL标准库之条件变量(condition_variable)
沉默、凝视的博客
10-08 1844
STL标准库线程同步条件变量的应用
std::condition_variable.wait_for
03-29
std::condition_variable.wait_for()是C++中std::condition_variable类的一个成员函数，用于在指定时间内等待条件变量满足特定条件。它的语法如下： ```cpp template< class Rep, class Period > std::cv_status wait_for( std::unique_lock<std::mutex>& lock, const std::chrono::duration<Rep, Period>& timeout_duration ); ``` 其中，`lock`是一个std::unique_lock<std::mutex>对象，用于保护条件变量。`timeout_duration`是一个std::chrono::duration对象，表示等待的时间段。 当调用std::condition_variable.wait_for()时，当前线程会被阻塞，直到以下情况之一发生： 1. 条件变量满足特定条件； 2. 等待时间超过了指定的时间段。 如果等待时间超过了指定的时间段，std::condition_variable.wait_for()会返回std::cv_status::timeout，表示等待超时。 以下是一个使用std::condition_variable.wait_for()的示例代码： ```cpp #include <iostream> #include <thread> #include <condition_variable> std::condition_variable cv; std::mutex mtx; bool ready = false; void worker() { std::this_thread::sleep_for(std::chrono::seconds(2)); std::unique_lock<std::mutex> lock(mtx); ready = true; cv.notify_one(); } int main() { std::cout << "Main thread starts." << std::endl; std::thread t(worker); std::unique_lock<std::mutex> lock(mtx); if (cv.wait_for(lock, std::chrono::seconds(1)) == std::cv_status::timeout) { std::cout << "Timeout occurred." << std::endl; } else { std::cout << "Condition variable is notified." << std::endl; } t.join(); std::cout << "Main thread ends." << std::endl; return 0; } ``` 在上面的示例中，主线程等待1秒钟，如果在1秒钟内没有收到通知，则输出"Timeout occurred."；如果在1秒钟内收到了通知，则输出"Condition variable is notified."。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值