你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

条件变量简析

[复制链接]
gaosmile 发布时间:2020-8-28 21:53
想必大家开发过程中都会用到多线程,用到多线程基本上都会用到条件变量,你理解的条件变量只是简单的wait和notify吗,最近工作中看同事也都只是简单的使用wait和notify,导致项目出现bug却不知如何fix bug,其实这里面还是有一些坑的,程序喵这里总结给大家。0 ]1 H3 Q2 H, C+ I  J, g
本文内容简介:
. J7 Y9 F. u- M" `9 o  [7 b6 n/ @
    ( ]7 l) K- V- U, r' t3 z) J
    * G& u5 C; e) b' W! d
  • 什么是条件变量?
  • 条件变量如何使用?
  • 如何解决条件变量的信号丢失问题?
  • 如何解决条件变量的虚假唤醒问题?

    + e% K, C; g& [0 O9 E. [' _; \* n" X
  • 条件变量为什么一定要和锁配合使用?
    3 P, [' s9 {/ ]3 r! }+ j5 F: A
    1 J4 D) b1 C( S$ h( ]% j' X

2 O* t7 _) F1 u4 G

% Z+ l- I5 F) C8 a$ T2 V+ R5 U. I5 F
1

9 f/ y+ w1 S3 \& }3 @2 J( o, C  E" L( W
什么是条件变量?

) d' z* e: k; P' ^0 e& i* i$ N4 V
条件变量是多线程程序中用来实现等待和唤醒逻辑常用的方法。通常有wait和notify两个动作,wait用于阻塞挂起线程A,直到另一个线程B通过通过notify唤醒线程A,唤醒后线程A会继续运行。
- y  o$ Y! _5 Q  ]/ \/ C/ y
条件变量在多线程中很常用,在有名的生产者和消费者问题中,消费者如何知道生成者是否生产出了可以消费的产品,通过while循环不停的去判断是否有可消费的产品?众所周知,死循环极其消耗CPU性能,所以需要使用条件变量来阻塞线程,降低CPU占用率。8 F' @) \* y2 W+ @* b; \: ~
3 t6 A, F: H( c* u( a) e0 R% z
2

7 g! Q/ T4 C9 ^$ j) }" T! G
条件变量的使用
拿生产者和消费者问题举例,看下面这段代码:

  1. ' N% Q! y( j# e! ~
  2. std::mutex mutex;
    + C" ?8 t# ~! W3 G  d
  3. std::condition_variable cv;
    % W0 L3 f7 `7 d4 K5 K
  4. std::vector<int> vec;8 D3 ~4 m& F  |3 [
  5. % W7 w+ X. e$ T
  6. void Consume() {5 z! a5 _) I, e4 t, H' F2 A
  7.   std::unique_lock<std::mutex> lock(mutex);
    $ u- J( T$ ]" y& q8 k$ j, `
  8.   cv.wait(lock);
    4 E. m1 w3 l+ \( d; s- ?0 N( [$ k% M
  9.   std::cout << "consume " << vec.size() << "\n";9 T5 s7 b. |, R$ {
  10. }
    ! X) @+ O- h+ g8 x6 H

  11. / |5 d/ K+ m4 Q! d, |
  12. void Produce() {
    ) p) Q. F" v1 }3 c$ M% `
  13.   std::unique_lock<std::mutex> lock(mutex);' C$ N! K4 F/ P: `; R
  14.   vec.push_back(1);
    ; V* ^' \' o; P, r, x: s/ B* X
  15.   cv.notify_all();
    % N4 G2 H! w* ~4 f5 q' |: Y
  16.   std::cout << "produce \n";
    & l  Y1 e  O" a8 h$ {$ Y
  17. }5 P. k. B$ }; y: ^

  18. : ?  F6 U1 c0 k; h
  19. int main() {
      a; Y' L/ R  [8 ~
  20.   std::thread t(Consume);! r& n3 q1 @: b6 _# L: |
  21.   t.detach();$ T1 l& V0 r: B& [) I2 M4 h
  22.   Produce();
    - D2 n: A( |/ h: K
  23.   return 0;
    ' L1 ?0 e$ p1 K4 ]+ H& z6 i* K
  24. }
复制代码
本意是消费者线程阻塞,等待生产者生产数据后去通知消费者线程,这样消费者线程就可以拿到数据去消费。
但这里有个问题:
如果先执行的Produce(),后执行的Consume(),生产者提前生产出了数据,去通知消费者,但是此时消费者线程如果还没有执行到wait语句,即线程还没有处于挂起等待状态,线程没有等待此条件变量上,那通知的信号就丢失了,后面Consume()中才执行wait处于等待状态,但此时生产者已经不会再触发notify,那消费者线程就会始终阻塞下去,出现bug。
如何解决这个问题呢?可以附加一个判断条件,就可以解决这种信号丢失问题,见代码:, _, R* k2 }8 [: P8 I* H: X

  1. / ^) p# T5 ~2 v1 j) g0 }
  2. std::mutex mutex;
    ; t9 m+ P( h0 h, n; I$ \& S
  3. std::condition_variable cv;
    1 |9 F( v6 v/ X  B3 r
  4. std::vector<int> vec;% Z' D2 @) J  I+ U; F# a
  5. 1 X8 l( x' M# H: C) l) i4 c' h
  6. void Consumer() {
    7 K( \/ t) d# y
  7.   std::unique_lock<std::mutex> lock(mutex);6 |! F! [* p1 }: ]8 \, C" i
  8.   if (vec.empty()) { // 加入此判断条件. R1 P6 C) [" V' h
  9.       cv.wait(lock);8 ]; S% A2 U/ e' L
  10.   }
    * {1 J6 m; S, u$ E: P  w
  11.   std::cout << "consumer " << vec.size() << "\n";* {5 V8 ~+ q8 j% H
  12. }' ~5 @5 r+ x( o/ T* c

  13. 9 Y# N# r, h) B' q
  14. void Produce() {1 L/ L, H6 q& t- |9 H: P
  15.   std::unique_lock<std::mutex> lock(mutex);
    9 q9 K) B8 @1 o0 x4 z8 o
  16.   vec.push_back(1);! ^/ Y1 x- n4 B1 S. Q& e+ y
  17.   cv.notify_all();
    4 T* }1 V+ p$ @( q* k  ?( q
  18.   std::cout << "produce \n";
    ' r8 q. y) C6 T( V1 c
  19. }5 n4 }( A- x2 M- F, S9 R4 B! j& m

  20. & _2 h" _# ~0 F# _- j8 Z
  21. int main() {
    6 o0 g/ I2 O2 G
  22.   std::thread t(Consumer);3 s( t9 ]6 ~, I* T$ z, S+ x' {
  23.   t.detach();' i5 V1 n4 s; n, l+ V: S- B$ k
  24.   Produce();( e' |9 s. v0 F6 I" g& R
  25.   return 0;
    # t. o% o8 }2 T8 H  m
  26. }
复制代码
通过增加附加条件可以解决信号丢失的问题,但这里还有个地方需要注意,消费者线程处于wait阻塞状态时,即使没有调用notify,操作系统也会有一些概率会唤醒处于阻塞的线程,使其继续执行下去,这就是虚假唤醒问题,当出现了虚假唤醒后,消费者线程继续执行,还是没有可以消费的数据,出现了bug。  % H" U( a  X' `1 X
那怎么解决虚假唤醒的问题呢,可以在线程由阻塞状态被唤醒后继续判断附加条件,看是否满足唤醒的条件,如果满足则继续执行,如果不满足,则继续去等待,体现在代码中,即将if判断改为while循环判断,见代码:
- F( c/ m4 L5 }) o! Y5 ^. B
  1. % l3 T6 L  d+ |: U0 z# \# l0 g
  2. std::mutex mutex;
    " n; x1 J# F, k+ \1 o. t$ ]
  3. std::condition_variable cv;
    + r7 A# S, E" r4 Y' r2 s: F2 w2 o
  4. std::vector<int> vec;
    " e5 A' O) g7 K

  5. . ]1 y  P, B9 e+ r8 _9 D4 Z
  6. void Consumer() {
    1 i; V% W2 a" E3 R* ^( Q( D. Z$ T2 |
  7.   std::unique_lock<std::mutex> lock(mutex);
    9 ^7 ^% s, }& F' v: o2 z* w
  8.   while (vec.empty()) { // 将if改为while
    . l. @3 M" a7 l- F& W
  9.       cv.wait(lock);9 f( R1 `5 L9 z0 N
  10.   }
    * L0 U$ _$ o; Q2 _' u  n5 x: d3 g
  11.   std::cout << "consumer " << vec.size() << "\n";, M& ?) S( n& V4 v
  12. }
    5 F/ J# A: v/ }! K7 W
  13. % F. w- v( s& P/ ?
  14. void Produce() {2 O- c- Y' y( Q5 A
  15.   std::unique_lock<std::mutex> lock(mutex);  R- {# t( A  x' |, A
  16.   vec.push_back(1);
    2 M1 ^0 \# O7 ?
  17.   cv.notify_all();0 o( m6 {0 {# W( e( a1 Z) G
  18.   std::cout << "produce \n";6 `1 U+ p! k& l6 E& F! r) U
  19. }
    ! Q7 v# z7 u. t7 d" m
  20. 0 L, B5 F7 g( j/ C
  21. int main() {% E7 G. r9 G& f9 s+ k. a0 v
  22.   std::thread t(Consumer);6 N! K6 j+ m5 E/ }; ~( U
  23.   t.detach();
    . d! ]7 ^2 i6 {- M
  24.   Produce();8 ^2 p: E0 g2 b8 y/ H1 |5 \* q8 f
  25.   return 0;, A$ _2 N6 Q% x5 j+ c  W
  26. }
复制代码
看到这里相信你已经明白条件变量的使用啦,需要使用while循环附加判断条件来解决条件变量的信号丢失和虚假唤醒问题。
6 u  s9 y7 U9 W8 t% a' x8 i
7 R% C3 l0 U1 L

( O( _+ M) w, n5 f2 I7 h2 \  ?( ?
3

1 {. ]; e& G" T
有没有更简单的“避坑”方式

6 c9 Y2 d1 N7 K* E3 Y! @; X4 \1 L
难道我们每次都必须要使用while循环和附加条件来操作条件变量吗?这岂不是很麻烦?
7 }. R0 a0 ^2 Q* K
NO!
# l. p* |/ C! v  g; L
在C++中其实有更好的封装,只需要调用wait函数时,在参数中直接添加附加条件就好了,内部已经做好了while循环判断,直接使用即可,见代码:
3 c- @& w5 T; o
  1. 0 O: Z2 a7 n+ k7 s! O) I
  2. std::mutex mutex;# |" O' X* u% s
  3. std::condition_variable cv;: z# V  ?# V: X# g- t, ?8 E7 Y
  4. std::vector<int> vec;: f8 i3 t3 A) S- c

  5.   ^+ X5 ~0 E0 q6 P; B/ B
  6. void Consumer() {
    $ H7 y6 e8 f8 m
  7.   std::unique_lock<std::mutex> lock(mutex);  b( u% n/ j1 Z4 R! |
  8.   cv.wait(lock, [&](){ return !vec.empty(); }); // 这里可以直接使用C++的封装
    " M9 R; r& h) v$ r
  9.   std::cout << "consumer " << vec.size() << "\n";
    4 X% g$ n/ m! ]1 c$ K' K; _8 J
  10. }) \: F2 P3 o# R- |. l5 J# T, v8 |* O

  11. , O+ P9 m# W2 g8 M& O
  12. void Produce() {" z0 B1 v6 c% z0 A$ c
  13.   std::unique_lock<std::mutex> lock(mutex);1 S/ V+ h6 |1 {5 i' X8 F" j
  14.   vec.push_back(1);
    4 ?1 \2 M. N2 d  M; p3 l9 k! h
  15.   cv.notify_all();  M% h* @* z8 b( i. E# \. W. Q  G
  16.   std::cout << "produce \n";
    , t" l9 t1 c4 t9 R- s0 K' }
  17. }
    6 t. t! s8 @, j1 ]4 j* ]" p8 T$ R

  18. * J2 `& K7 C; z8 e* V
  19. int main() {
    8 f. t4 J8 e3 ?2 B
  20.   std::thread t(Consumer);5 _& e) X# _2 e# e. l* j
  21.   t.detach();
    / |, {' T9 `8 `  U9 m1 H
  22.   Produce();
    2 z* P* L0 F. g7 b' ?' Q' e/ P
  23.   return 0;: x5 j; T6 t+ I( Q* i/ b3 t6 ?
  24. }
复制代码
但在C语言中就没办法啦,大家只能自己做一层封装啦。
0 S: y& d: ^: [1 x
8 ^7 \+ n3 ^1 u. c4 l
4
. h. E2 G3 R% J' W: j
为什么条件变量需要和锁配合使用?  T3 h, R' @1 K" E4 K
' k1 j4 |$ N: l% M! j5 X( m
为什么叫条件变量呢?
; s! ?; F. p2 Q! z6 J9 c  f, P
因为内部是通过判断及修改某个全局变量来决定线程的阻塞与唤醒,多线程操作同一个变量肯定需要加锁来使得线程安全。同时,一个简单的wait函数调用内部会很复杂的,有可能线程A调用了wait函数但是还没有进入到wait阻塞等待前,另一个线程B在此时却调用了notify函数,此时nofity的信号就丢失啦,如果加了锁,线程B必须等待线程A释放了锁并进入了等待状态后才可以调用notify,继而防止信号丢失。
关于条件变量就介绍到这里,希望大家能有所收获,平时使用过程中可以避掉条件变量的坑。

5 i3 G9 R* |; L$ l! O
# b  G) o6 D- J% N4 K6 o) p( E
赞 收藏 评论0 发布时间:2020-8-28 21:53

举报

0个回答
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版