|
想必大家开发过程中都会用到多线程,用到多线程基本上都会用到条件变量,你理解的条件变量只是简单的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条件变量的使用 拿生产者和消费者问题举例,看下面这段代码:
' N% Q! y( j# e! ~- std::mutex mutex;
+ C" ?8 t# ~! W3 G d - std::condition_variable cv;
% W0 L3 f7 `7 d4 K5 K - std::vector<int> vec;8 D3 ~4 m& F |3 [
- % W7 w+ X. e$ T
- void Consume() {5 z! a5 _) I, e4 t, H' F2 A
- std::unique_lock<std::mutex> lock(mutex);
$ u- J( T$ ]" y& q8 k$ j, ` - cv.wait(lock);
4 E. m1 w3 l+ \( d; s- ?0 N( [$ k% M - std::cout << "consume " << vec.size() << "\n";9 T5 s7 b. |, R$ {
- }
! X) @+ O- h+ g8 x6 H
/ |5 d/ K+ m4 Q! d, |- void Produce() {
) p) Q. F" v1 }3 c$ M% ` - std::unique_lock<std::mutex> lock(mutex);' C$ N! K4 F/ P: `; R
- vec.push_back(1);
; V* ^' \' o; P, r, x: s/ B* X - cv.notify_all();
% N4 G2 H! w* ~4 f5 q' |: Y - std::cout << "produce \n";
& l Y1 e O" a8 h$ {$ Y - }5 P. k. B$ }; y: ^
: ? F6 U1 c0 k; h- int main() {
a; Y' L/ R [8 ~ - std::thread t(Consume);! r& n3 q1 @: b6 _# L: |
- t.detach();$ T1 l& V0 r: B& [) I2 M4 h
- Produce();
- D2 n: A( |/ h: K - return 0;
' L1 ?0 e$ p1 K4 ]+ H& z6 i* K - }
复制代码本意是消费者线程阻塞,等待生产者生产数据后去通知消费者线程,这样消费者线程就可以拿到数据去消费。 但这里有个问题: 如果先执行的Produce(),后执行的Consume(),生产者提前生产出了数据,去通知消费者,但是此时消费者线程如果还没有执行到wait语句,即线程还没有处于挂起等待状态,线程没有等待此条件变量上,那通知的信号就丢失了,后面Consume()中才执行wait处于等待状态,但此时生产者已经不会再触发notify,那消费者线程就会始终阻塞下去,出现bug。 如何解决这个问题呢?可以附加一个判断条件,就可以解决这种信号丢失问题,见代码:, _, R* k2 }8 [: P8 I* H: X
/ ^) p# T5 ~2 v1 j) g0 }- std::mutex mutex;
; t9 m+ P( h0 h, n; I$ \& S - std::condition_variable cv;
1 |9 F( v6 v/ X B3 r - std::vector<int> vec;% Z' D2 @) J I+ U; F# a
- 1 X8 l( x' M# H: C) l) i4 c' h
- void Consumer() {
7 K( \/ t) d# y - std::unique_lock<std::mutex> lock(mutex);6 |! F! [* p1 }: ]8 \, C" i
- if (vec.empty()) { // 加入此判断条件. R1 P6 C) [" V' h
- cv.wait(lock);8 ]; S% A2 U/ e' L
- }
* {1 J6 m; S, u$ E: P w - std::cout << "consumer " << vec.size() << "\n";* {5 V8 ~+ q8 j% H
- }' ~5 @5 r+ x( o/ T* c
9 Y# N# r, h) B' q- void Produce() {1 L/ L, H6 q& t- |9 H: P
- std::unique_lock<std::mutex> lock(mutex);
9 q9 K) B8 @1 o0 x4 z8 o - vec.push_back(1);! ^/ Y1 x- n4 B1 S. Q& e+ y
- cv.notify_all();
4 T* }1 V+ p$ @( q* k ?( q - std::cout << "produce \n";
' r8 q. y) C6 T( V1 c - }5 n4 }( A- x2 M- F, S9 R4 B! j& m
& _2 h" _# ~0 F# _- j8 Z- int main() {
6 o0 g/ I2 O2 G - std::thread t(Consumer);3 s( t9 ]6 ~, I* T$ z, S+ x' {
- t.detach();' i5 V1 n4 s; n, l+ V: S- B$ k
- Produce();( e' |9 s. v0 F6 I" g& R
- return 0;
# t. o% o8 }2 T8 H m - }
复制代码通过增加附加条件可以解决信号丢失的问题,但这里还有个地方需要注意,消费者线程处于wait阻塞状态时,即使没有调用notify,操作系统也会有一些概率会唤醒处于阻塞的线程,使其继续执行下去,这就是虚假唤醒问题,当出现了虚假唤醒后,消费者线程继续执行,还是没有可以消费的数据,出现了bug。 % H" U( a X' `1 X
那怎么解决虚假唤醒的问题呢,可以在线程由阻塞状态被唤醒后继续判断附加条件,看是否满足唤醒的条件,如果满足则继续执行,如果不满足,则继续去等待,体现在代码中,即将if判断改为while循环判断,见代码:
- F( c/ m4 L5 }) o! Y5 ^. B - % l3 T6 L d+ |: U0 z# \# l0 g
- std::mutex mutex;
" n; x1 J# F, k+ \1 o. t$ ] - std::condition_variable cv;
+ r7 A# S, E" r4 Y' r2 s: F2 w2 o - std::vector<int> vec;
" e5 A' O) g7 K
. ]1 y P, B9 e+ r8 _9 D4 Z- void Consumer() {
1 i; V% W2 a" E3 R* ^( Q( D. Z$ T2 | - std::unique_lock<std::mutex> lock(mutex);
9 ^7 ^% s, }& F' v: o2 z* w - while (vec.empty()) { // 将if改为while
. l. @3 M" a7 l- F& W - cv.wait(lock);9 f( R1 `5 L9 z0 N
- }
* L0 U$ _$ o; Q2 _' u n5 x: d3 g - std::cout << "consumer " << vec.size() << "\n";, M& ?) S( n& V4 v
- }
5 F/ J# A: v/ }! K7 W - % F. w- v( s& P/ ?
- void Produce() {2 O- c- Y' y( Q5 A
- std::unique_lock<std::mutex> lock(mutex); R- {# t( A x' |, A
- vec.push_back(1);
2 M1 ^0 \# O7 ? - cv.notify_all();0 o( m6 {0 {# W( e( a1 Z) G
- std::cout << "produce \n";6 `1 U+ p! k& l6 E& F! r) U
- }
! Q7 v# z7 u. t7 d" m - 0 L, B5 F7 g( j/ C
- int main() {% E7 G. r9 G& f9 s+ k. a0 v
- std::thread t(Consumer);6 N! K6 j+ m5 E/ }; ~( U
- t.detach();
. d! ]7 ^2 i6 {- M - Produce();8 ^2 p: E0 g2 b8 y/ H1 |5 \* q8 f
- return 0;, A$ _2 N6 Q% x5 j+ c W
- }
复制代码看到这里相信你已经明白条件变量的使用啦,需要使用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 - 0 O: Z2 a7 n+ k7 s! O) I
- std::mutex mutex;# |" O' X* u% s
- std::condition_variable cv;: z# V ?# V: X# g- t, ?8 E7 Y
- std::vector<int> vec;: f8 i3 t3 A) S- c
^+ X5 ~0 E0 q6 P; B/ B- void Consumer() {
$ H7 y6 e8 f8 m - std::unique_lock<std::mutex> lock(mutex); b( u% n/ j1 Z4 R! |
- cv.wait(lock, [&](){ return !vec.empty(); }); // 这里可以直接使用C++的封装
" M9 R; r& h) v$ r - std::cout << "consumer " << vec.size() << "\n";
4 X% g$ n/ m! ]1 c$ K' K; _8 J - }) \: F2 P3 o# R- |. l5 J# T, v8 |* O
, O+ P9 m# W2 g8 M& O- void Produce() {" z0 B1 v6 c% z0 A$ c
- std::unique_lock<std::mutex> lock(mutex);1 S/ V+ h6 |1 {5 i' X8 F" j
- vec.push_back(1);
4 ?1 \2 M. N2 d M; p3 l9 k! h - cv.notify_all(); M% h* @* z8 b( i. E# \. W. Q G
- std::cout << "produce \n";
, t" l9 t1 c4 t9 R- s0 K' } - }
6 t. t! s8 @, j1 ]4 j* ]" p8 T$ R
* J2 `& K7 C; z8 e* V- int main() {
8 f. t4 J8 e3 ?2 B - std::thread t(Consumer);5 _& e) X# _2 e# e. l* j
- t.detach();
/ |, {' T9 `8 ` U9 m1 H - Produce();
2 z* P* L0 F. g7 b' ?' Q' e/ P - return 0;: x5 j; T6 t+ I( Q* i/ b3 t6 ?
- }
复制代码但在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 |