条件变量的正确使用

最新推荐文章于 2023-05-30 17:15:59 发布
最新推荐文章于 2023-05-30 17:15:59 发布
阅读量376 收藏 1
点赞数 1
分类专栏： # cpp多线程精进
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43325061/article/details/118556625
版权

条件变量的正确使用

陈硕 https://www.cnblogs.com/Solstice/p/3309089.html

TL;DR 如果你能一眼看出 https://gist.github.com/chenshuo/6430925 中的那 8 个 Waiter classes 哪些是对的哪些是错的，本文就不必看了。

我质疑某本书对 Pthreads 条件变量的封装是错的，因为它没有把 mutex 的 lock()/unlock() 函数暴露出来，导致无法实用。后来大家讨论的分歧是这个 cond class 是不是通用的条件变量封装，还是只是一个特殊的“事件等待器”。作为事件等待器，其实现也是错的，因为存在丢失事件的可能，可以算是初学者使用条件变量的典型错误。

本文的代码位于 recipes/thread/test/Waiter_test.cc，这里提到的某书的版本相当于 Waiter1 class。

我在拙作《Linux 多线程服务端编程：使用 muduo C++ 网络库》第 2.2 节总结了条件变量的使用要点：

条件变量只有一种正确使用的方式，几乎不可能用错。对于 wait 端：

  1. 必须与 mutex 一起使用，该布尔表达式的读写需受此 mutex 保护。
  2. 在 mutex 已上锁的时候才能调用 wait()。
  3. 把判断布尔条件和 wait() 放到 while 循环中。

对于 signal/broadcast 端：

  1. 不一定要在 mutex 已上锁的情况下调用 signal （理论上）。
  2. 在 signal 之前一般要修改布尔表达式。
  3. 修改布尔表达式通常要用 mutex 保护（至少用作 full memory barrier）。
  4. 注意区分 signal 与 broadcast：“broadcast 通常用于表明状态变化，signal 通常用于表示资源可用。（broadcast should generally be used to indicate state change rather than resource availability。）”

如果用条件变量来实现一个“事件等待器/Waiter”，正确的做法是怎样的？我的最终答案见 WaiterInMuduo class。“事件等待器”的一种用途是程序启动时等待初始化完成，也可以直接用 muduo::CountDownLatch 到达相同的目的，将初值设为 1 即可。

以下根据微博上的讨论过程给出几个正确或错误的版本，博大家一笑。只要记住 Pthread 的条件变量是边沿触发（edge trigger），即 signal()/broadcast() 只会唤醒已经等在 wait() 上的线程(s)，我们在编码时必须要考虑 signal() 早于 wait() 的可能，那么就很容易判断以下各个版本的正误了。代码见 recipes/thread/test/Waiter_test.cc。

此处贴上。

#include "../Condition.h"
#include "../Mutex.h"
#include "../Thread.h"

#include <boost/bind.hpp>

#include <signal.h>

// Interface of Waiter, also takes care of mutex_ & cond_ init and destroy.
class Waiter : boost::noncopyable
{
 public:
  virtual void wait() = 0;
  virtual void signal() = 0;

 protected:
  Waiter()
  {
    pthread_mutex_init(&mutex_, NULL);
    pthread_cond_init(&cond_, NULL);
  }

  ~Waiter()
  {
    pthread_mutex_destroy(&mutex_);
    pthread_cond_destroy(&cond_);
  }

  pthread_mutex_t mutex_;
  pthread_cond_t cond_;
};

// Version 1: orininal from the book
// Incorrect, could lose signal
class Waiter1 : public Waiter
{
 public:
  void wait() override
  {
    pthread_mutex_lock(&mutex_);
    pthread_cond_wait(&cond_, &mutex_);
    pthread_mutex_unlock(&mutex_);
  }

  void signal() override
  {
    pthread_cond_signal(&cond_);
  }
};

// Version 2: signal in lock
// Incorrect, could lose signal
class Waiter2 : public Waiter
{
 public:
  void wait() override
  {
    pthread_mutex_lock(&mutex_);
    pthread_cond_wait(&cond_, &mutex_);
    pthread_mutex_unlock(&mutex_);
  }

  void signal() override
  {
    pthread_mutex_lock(&mutex_);
    pthread_cond_signal(&cond_);
    pthread_mutex_unlock(&mutex_);
  }
};

// Version 3: add a boolean member
// Incorrect, spurious wakeup
class Waiter3 : public Waiter
{
 public:
  void wait() override
  {
    pthread_mutex_lock(&mutex_);
    if (!signaled_)
    {
      pthread_cond_wait(&cond_, &mutex_);
    }
    pthread_mutex_unlock(&mutex_);
  }

  void signal() override
  {
    pthread_mutex_lock(&mutex_);
    signaled_ = true;
    pthread_cond_signal(&cond_);
    pthread_mutex_unlock(&mutex_);
  }

 private:
  bool signaled_ = false;
};

// Version 4: wait in while-loop
// Correct, signal before unlock
class Waiter4 : public Waiter
{
 public:
  void wait() override
  {
    pthread_mutex_lock(&mutex_);
    while (!signaled_)
    {
      pthread_cond_wait(&cond_, &mutex_);
    }
    pthread_mutex_unlock(&mutex_);
  }

  void signal() override
  {
    pthread_mutex_lock(&mutex_);
    signaled_ = true;
    pthread_cond_signal(&cond_);
    pthread_mutex_unlock(&mutex_);
  }

 private:
  bool signaled_ = false;
};

// Version 5: wait in while-loop
// Correct, signal after unlock
class Waiter5 : public Waiter
{
 public:
  void wait() override
  {
    pthread_mutex_lock(&mutex_);
    while (!signaled_)
    {
      pthread_cond_wait(&cond_, &mutex_);
    }
    pthread_mutex_unlock(&mutex_);
  }

  void signal() override
  {
    pthread_mutex_lock(&mutex_);
    signaled_ = true;
    pthread_mutex_unlock(&mutex_);
    pthread_cond_signal(&cond_);
  }

 private:
  bool signaled_ = false;
};

// Note: version 4 is as efficient as version 5 because of "wait morphing"

// Version 6: signal before set boolean flag
// Correct or not?
class Waiter6 : public Waiter
{
 public:
  void wait() override
  {
    pthread_mutex_lock(&mutex_);
    while (!signaled_)
    {
      pthread_cond_wait(&cond_, &mutex_);
    }
    pthread_mutex_unlock(&mutex_);
  }

  void signal() override
  {
    pthread_mutex_lock(&mutex_);
    pthread_cond_signal(&cond_);
    signaled_ = true;
    pthread_mutex_unlock(&mutex_);
  }

 private:
  bool signaled_ = false;
};

// Version 8: modify signaled_ without lock
// Incorrect, data-race and could lose signal
class Waiter8 : public Waiter
{
 public:
  void wait() override
  {
    pthread_mutex_lock(&mutex_);
    while (!signaled_)
    {
      pthread_cond_wait(&cond_, &mutex_);
    }
    pthread_mutex_unlock(&mutex_);
  }

  void signal() override
  {
    signaled_ = true;
    pthread_cond_signal(&cond_);
  }

 private:
  bool signaled_ = false;
};

// Version 7: broadcast to wakeup multiple waiting threads
// Probably the best version among above.
class Waiter7 : public Waiter
{
 public:
  void wait() override
  {
    pthread_mutex_lock(&mutex_);
    while (!signaled_)
    {
      pthread_cond_wait(&cond_, &mutex_);
    }
    pthread_mutex_unlock(&mutex_);
  }

  void signal() override // Sorry, bad name in base class, poor OOP
  {
    broadcast();
  }

  void broadcast()
  {
    pthread_mutex_lock(&mutex_);
    pthread_cond_broadcast(&cond_);
    signaled_ = true;
    pthread_mutex_unlock(&mutex_);
  }

 private:
  bool signaled_ = false;
};

// Same as version 7, with muduo library
class WaiterInMuduo : boost::noncopyable
{
 public:
  WaiterInMuduo()
    : cond_(mutex_)
  {
  }

  void wait()
  {
    muduo::MutexLockGuard lock(mutex_);
    while (!signaled_)
    {
      cond_.wait();
    }
  }

  void broadcast()
  {
    muduo::MutexLockGuard lock(mutex_);
    signaled_ = true;
    cond_.notifyAll();
  }

 private:
  muduo::MutexLock mutex_;
  muduo::Condition cond_;
  bool signaled_ = false;
};

void initAndRefresh(Waiter* waiter)
{
  printf("init: running\n");

  struct timespec ts = { 0, 500*1000*1000 };
  nanosleep(&ts, NULL);  // initialization takes 500ms

  waiter->signal();
  printf("init: signaled\n");
}

void runServer(Waiter* waiter, int sec)
{
  muduo::Thread initThread(boost::bind(initAndRefresh, waiter));
  initThread.start();
  printf("main: init thread started\n");

  struct timespec ts = { sec, 0 };
  nanosleep(&ts, NULL); // do some work before calling wait()

  printf("main: waiting\n");
  waiter->wait();
  printf("main: done\n");
}

void sigalarm(int)
{
  write(1, "\nFAILED\n", 8);
  exit(1);
}

int main(int argc, char* argv[])
{
  signal(SIGALRM, sigalarm);
  alarm(5);

  Waiter1 w1;
  Waiter2 w2;
  Waiter3 w3;
  Waiter4 w4;
  Waiter5 w5;
  Waiter6 w6;
  Waiter7 w7;
  Waiter8 w8;
  WaiterInMuduo waiterInMuduo;

  Waiter* waiters[] = { NULL, &w1, &w2, &w3, &w4, &w5, &w6, &w7, &w8 };
  int whichWaiter = argc > 1 ? atoi(argv[1]) : 5;
  if (!(whichWaiter > 0 && whichWaiter <= 8))
  {
    printf("Unknown waiter, must between 1 and 8, inclusive.\n");
    return 1;
  }
  Waiter* waiter = waiters[whichWaiter];

  int sec = 0;
  printf("test 1: wait() before signal().\n");
  runServer(waiter, sec);

  printf("\ntest 2: wait() after signal().\n");
  sec = 1;
  runServer(waiter, sec);

  printf("\nPASSED!\n");
}

版本一：错误。某书上的原始版，有丢失事件的可能。

版本二：错误。lock() 之后再 signal()，同样有丢失事件的可能。

版本三：错误。引入了 bool signaled_; 条件，但没有正确处理 spurious wakeup。

版本四五六：正确。仅限 single waiter 使用。

版本七：最佳。可供 multiple waiters 使用。

版本八：错误。存在 data race，且有丢失事件的可能。理由见 http://stackoverflow.com/questions/4544234/calling-pthread-cond-signal-without-locking-mutex

总结：使用条件变量，调用 signal() 的时候无法知道是否已经有线程等待在 wait() 上。因此一般总是要先修改“条件”，使其为 true，再调用 signal()；这样 wait 线程先检查“条件”，只有当条件不成立时才去 wait()，避免了丢事件的可能。换言之，通过使用“条件”，将边沿触发（edge trigger）改为电平触发（level trigger）。这里“修改条件”和“检查条件”都必须在 mutex 保护下进行，而且这个 mutex 必须用于配合 wait()。

思考题：如果用两个 mutex，一个用于保护“条件”，另一个专门用于和 cond 配合 wait()，会出现什么情况？

最后注明一点，http://stackoverflow.com/questions/6419117/signal-and-unlock-order 这篇帖子里对 spurious wakeup 的解释是错的，spurious wakeup 指的是一次 signal() 调用唤醒两个或以上 wait()ing 的线程，或者没有调用 signal() 却有线程从 wait() 返回。manpage 里对 Pthreads 系列函数的介绍非常到位，值得细读。

infralan
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈Linux条件变量的使用
09-15
下面小编就为大家带来一篇浅谈Linux条件变量的使用。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
我不允许你不懂条件变量
极客熊猫
06-10 239
更多文章分享在个人微信公众号：极客熊猫 欢迎扫码关注： 互斥与同步 在多线程编程中，有两大问题需要解决：互斥和同步。这两个问题经常放在一起说，但它们还是存在一些差别的。 互斥：由于线程间存在共享数据，当多线程并发地对共享数据进行操作（主要是写操作）时，如不加以管理，可能导致数据不一致问题。互斥就是一个共享数据在同一时刻只能被一个线程使用，这样就保证了共享数据的一致性。 同步：同步比互斥要更加严格。互斥只是规定多个线程不能同时使用共享数据，但是对谁先使用谁后使用并没有作出限制；而同步是指线程间存在依赖，它们
条件变量的用法
lidw0431的博客
03-11 376
std::condition_variable 参考资料 https://en.cppreference.com/w/cpp/thread/condition_variable https://en.cppreference.com/w/cpp/thread/condition_variable/wait 作用 条件变量，头文件<condition_variable>。用于多个线程并发操作共享变量（即条件）时，阻塞其中的一个或者多个变量，在满足指定条件（已修改共享变量，或者阻塞超时）下唤醒这
条件变量的简单使用
青海蓝田的博客
04-07 133
条件变量的创建和销毁 #include<pthread.h> int pthread_cond_init(pthread_cond_t *cond，pthread_condattr_t *cond_attr); int pthread_cond_destroy(pthread_cond_t *cond); 返回值：成功返回0，出错返回错误编号 参数： cond：条件变量 attr：条件变量属性 条件变量的等待操作 #include&l...
条件变量的使用
weixin_48256350的博客
03-28 786
1. 初始化条件变量 1） 动态初始化 — pthread_cond_init() --> man 3 pthread_cond_init #include <pthread.h> int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr); cond: 条件变量的地址 attr: 属性变量，普通属性： NULL 返回值： 成功：
条件变量的使用方法（笔记）
qq_36822217的博客
03-21 1155
条件变量相关函数 初始化一个条件变量 #include <pthread.h> int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr); 常量初始化 pthread_cond_t cond = PTHREAD_COND_INITIA...
(16) 若变量已正确定义并赋值，下面符合C语言语法的表达式是( ).doc
07-01
(16) 若变量已正确定义并赋值，下面符合C语言语法的表达式是( )
when:使用 setInterval 循环直到条件为真
06-05
我们使用它来测试第三方库是否已将正确的全局变量加载到window 。 不是很好，我知道。 有更好的主意吗？ 安装$ npm install do-when$ component install segmentio/when应用程序接口当（条件，回调，[间隔=10]） 当...
javascript里的条件判断
12-02
JavaScript 是一种可以在浏览器中运行的脚本语言，是一种弱语言（相... } 咱先不管上面的代码运行的结果正确与否，我给变量 s 赋的是字符型，而在后面的 if 条件判断式里是直接把变量 s 作为一个判断表达式写出
如何正确使用javascript 来进行我们的程序开发
01-19
今天在github 上面找到了一个关于如何正确使用javascript 来进行我们的程序开发.我就恬不知耻的来了个原创啊..坑爹啊.拿来和大家分享一下吧. A mostly reasonable approach to Javascript. Types //类型 Objects //...
实验一 条件语句、循环语句的使用 2.switch 条件语句
12-06
项目2、使用switch 条件语句实现判断选择题对错的功能1）编写一个类Example122）定义一个变量answer用于存储答案选项3）用switch条件语句判断如果变量answer为B则正确，其它则错误4）如果变量answer不等于ABCD四个...
条件变量只有一种正确的使用方式
dreaming_qt的博客
07-15 66
条件变量只有一种正确的使用方式： std::unique_lock<std::mutex> locker(mutex) while (condition) { cond.wait(locker); } std::lock_guard<std::mutex> lck; change condition cond.notify_one()
linux中的条件变量的使用
热门推荐
hmxz2nn的博客
06-24 1万+
什么是条件变量 为何要用条件变量 条件变量的用法
条件变量基本使用
最新发布
qq_43341187的博客
05-30 710
信号会被多个线程收到，这叫线程的惊群效应。所以需要加上判断条件。必要性：为了实现等待某个资源，让线程休眠。应用场景：生产者消费者问题，是线程同步的一种手段。，在没有资源等待是是先。，则有可能会丢失信号。广播通知多个消费线程。休眠，等资源到了，再。
条件变量使用
sxl__wqy的博客
12-10 260
原文
【Windows】线程漫谈——线程同步之Slim读/写锁
weixin_30333885的博客
06-24 79
本系列意在记录Windwos线程的相关知识点，包括线程基础、线程调度、线程同步、TLS、线程池等。 Slim读/写锁 SRWLock的目的和关键段相同，对一个资源进行保护，构造了一段“原子访问”的代码，不让其他线程访问它。但与关键段不同的是SRWLock允许区分想要读取资源值的线程和想要写入资源值的线程，因为仅仅读取资源是不会破坏数据的，下面是Slim读/写锁的简单用法： SRWLOC...
线程同步:条件变量的使用细节分析
lihuanyuasas的专栏
07-31 396
如同互斥量和读写锁一样，条件变量也需要初始化和回收 #include int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr); int pthread_cond_destroy(pthread_cond_t *cond); 互斥量和读写锁解决了多线程访问共享变量
线程间使用条件变量同步正确方式
mumumuwudi的博客
08-26 2038
线程间同步标准的使用方式如下： thread 1: pthread_mutex_lock(&mutex); while (!condition) pthread_cond_wait(&cond, &mutex); func_1();/* do something that requires holding the mutex and condi
python 条件变量
03-30
条件变量是一种同步机制，用于线程之间的通信和协调。在 Python 中，条件变量可以用 threading 模块的 Condition 类来实现。 Condition 类有两个主要方法：wait() 和 notify()。wait() 方法用于等待条件变量的发生，如果条件不满足，线程就会阻塞在这里等待。notify() 方法用于通知等待条件变量的线程，让它们继续执行。 下面是一个简单的例子，演示了如何使用条件变量： ```python import threading class SharedCounter: def __init__(self, value=0): self.value = value self.cv = threading.Condition() def increment(self): with self.cv: self.value += 1 self.cv.notify_all() def decrement(self): with self.cv: while self.value == 0: self.cv.wait() self.value -= 1 counter = SharedCounter() def worker(): print('Starting worker') for i in range(10): counter.increment() print('Incremented: {}'.format(counter.value)) print('Exiting worker') threads = [] for i in range(5): t = threading.Thread(target=worker) t.start() threads.append(t) for t in threads: t.join() print('Final value: {}'.format(counter.value)) ``` 在这个例子中，我们创建了一个 SharedCounter 类，它包含一个整数值和一个条件变量。increment() 和 decrement() 方法分别用于增加和减少计数器的值。当计数器的值为 0 时，decrement() 方法会阻塞等待条件变量的发生。当 increment() 方法执行完成后，它会通知所有等待条件变量的线程，让它们继续执行。 我们创建了 5 个线程来同时访问 SharedCounter 对象，并在每个线程中调用 increment() 方法 10 次。由于 increment() 方法使用了条件变量，线程之间可以协调和同步，保证计数器的值始终正确。最后，我们输出了计数器的最终值。 总的来说，条件变量是一种非常有用的同步机制，可以用于解决多线程程序中的一些复杂问题。在 Python 中，使用 threading 模块的 Condition 类来实现条件变量非常简单。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值