嵌入式Linux：线程同步（互斥锁）

电子设计联盟

xikkpl01yji640525.gif

点击上方蓝色字体，关注我们
. d( x1 U# I! l# a. ~
互斥锁是一种二进制锁，也就是说它只有两种状态：锁定（locked）和解锁（unlocked）。
( J6 i" _, t. T4 B' ]# B
当一个线程想要访问受保护的共享资源时，它首先必须尝试锁定互斥锁，如果锁已经被其他线程持有，则它必须等待，直到锁被释放。

2 U3 p5 ~( N; L; }3 z4 q8 F7 E当线程完成对资源的操作后，它需要解锁互斥锁，以便其他线程可以访问该资源。
( z& i+ W6 f7 x  B% {
9 {2 L- `6 R; o0 s7 l7 A# Z. Z8 i& L互斥锁的工作原理：
5 h) U/ `" c% T

锁定（lock）：线程调用pthread_mutex_lock()，如果互斥锁已经解锁，则该线程成功锁定，并进入临界区访问共享资源；如果锁已被其他线程占有，则当前线程将阻塞，直到锁被释放。

解锁（unlock）：线程完成对共享资源的操作后，调用pthread_mutex_unlock()，这会释放锁，其他被阻塞的线程将有机会锁定并访问该资源。

在Linux下，线程互斥锁主要通过POSIX线程库（pthread）来实现，通常的步骤包括：
* p5 h) b- S9 [& M/ a$ Z

初始化互斥锁：使用pthread_mutex_init()或直接用静态初始化PTHREAD_MUTEX_INITIALIZER。

锁定互斥锁：在线程需要访问共享资源前，使用pthread_mutex_lock()锁定。

访问共享资源：执行需要对共享资源的操作。

解锁互斥锁：访问结束后，使用pthread_mutex_unlock()解锁。

销毁互斥锁：使用pthread_mutex_destroy()销毁互斥锁，通常在不再使用该互斥锁时进行。
& s% j* m+ N3 @; E- x
0 @4 i6 H  O7 Q( i6 P1 @1
7 i: j/ p+ f& j. t3 {( W' ^互斥锁的初始化
互斥锁在使用之前必须先进行初始化操作。

8 ]" v1 a! l4 b$ C4 u% q4 a2 M) D2 [可以通过两种方式来初始化互斥锁：静态初始化和动态初始化。
  N/ Q$ q% D5 L* `) O9 R
1.1、静态初始化
静态初始化使用 PTHREAD_MUTEX_INITIALIZER 宏来初始化互斥锁，这是一种常见且简便的初始化方法。

无需显式调用初始化函数，适用于全局互斥锁。

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
在这种方式下，互斥锁被设置为默认属性。静态初始化不需要任何额外参数，并且返回值是隐式的，不会返回错误码。
. T  |( [- r, w) T
1 D4 r6 v, i9 F* i+ P! V1 R5 e1.2、动态初始化
动态初始化通过 pthread_mutex_init() 函数完成，适用于需要在运行时动态分配的互斥锁，或需要自定义互斥锁属性的情况。
6 M; m- [! o/ [) {+ F

pthread_mutex_t mutex;pthread_mutexattr_t attr;pthread_mutexattr_init(&attr);  // 初始化互斥锁属性
8 e3 |3 D& s  B// 初始化互斥锁，第二个参数为属性，如果不需要自定义属性可以传入 NULLint ret = pthread_mutex_init(&mutex, &attr);if (ret != 0) {    // 处理初始化失败}pthread_mutexattr_destroy(&attr);  // 销毁属性
参数：

mutex：指向 pthread_mutex_t 类型互斥锁的指针。

attr：互斥锁的属性指针，可以设置互斥锁的行为。如果不需要自定义属性，传入 NULL 表示使用默认属性。
8 g) M8 O) h$ M. L' n& T3 N: T/ Y
返回值：成功时返回 0，失败时返回非零错误码。常见错误码包括：

EINVAL：attr 属性无效。

EBUSY：互斥锁已经被初始化。

ENOMEM：内存不足，无法分配资源。

2
' k  k  X8 s2 w5 c& S( T$ [  J( B互斥锁加锁与解锁
2.1、互斥锁加锁
' b; [. D- S: b4 j; E# B% S5 Opthread_mutex_lock() 用于对互斥锁加锁。

如果互斥锁已经被其他线程锁住，调用线程将进入阻塞状态，直到该互斥锁被解锁。

pthread_mutex_lock(&mutex);  // 加锁
$ L+ q/ g' b6 `1 `. V1 n参数：mutex 是指向要加锁的 pthread_mutex_t 互斥锁对象的指针。
返回值：成功时返回 0。如果出现错误，返回非零错误码：

EINVAL：互斥锁无效。

EDEADLK：线程试图递归加锁一个非递归互斥锁（导致死锁）。
2 }# E$ U0 S5 u9 X1 j, \
2.2、互斥锁解锁
pthread_mutex_unlock() 用于解锁已经加锁的互斥锁。
# f& U! @# e) x) b" Z
! u: q" [; M, t4 b; j如果其他线程正等待此互斥锁，它将被唤醒并获取锁。
$ g9 a9 F7 N/ ~6 H
( _( H* ?+ I& J8 E. r

pthread_mutex_unlock(&mutex);  // 解锁
+ V: p6 S2 t2 J; c0 l8 N
5 W$ K0 w! U* S! C0 V8 c9 _参数：mutex 是指向要解锁的 pthread_mutex_t 互斥锁对象的指针。
返回值：成功时返回 0。可能的错误码：

EINVAL：互斥锁无效。

EPERM：当前线程没有持有该互斥锁。

3
非阻塞加锁
, a0 L% {2 I- Opthread_mutex_trylock() 是一种非阻塞加锁操作。

3 g9 H7 y1 w1 {0 T  B- O7 N如果互斥锁已经被其他线程锁住，它不会阻塞，而是立即返回错误码 EBUSY。

int try_lock_example() {    int ret = pthread_mutex_trylock(&mutex);    if (ret == 0) {        // 锁定成功        printf("锁定成功！
/ I- K  m+ j5 K1 W  ~- R6 ~% ?");        pthread_mutex_unlock(&mutex);  // 解锁    } else if (ret == EBUSY) {        // 锁定失败，互斥锁已被其他线程持有        printf("锁定失败，互斥锁被占用。
");    } else {        // 其他错误        printf("尝试锁定时出现错误。
");    }    return 0;}
参数：mutex 是指向要加锁的 pthread_mutex_t 互斥锁对象的指针。
* ?+ C  t6 U/ ]$ A  \返回值：
# Y0 \7 Z9 |* ^3 P! p

0：成功加锁。

EBUSY：互斥锁已经被其他线程持有，无法加锁。

EINVAL：互斥锁无效。

! s! P) |5 b8 l- d7 I4
! T) K" A3 z/ _% `4 E$ i& B& A销毁互斥锁
5 R6 e/ b+ ]9 U( R使用完互斥锁后，应该通过 pthread_mutex_destroy() 释放与之相关的资源。

9 C8 T5 \- _% ]/ w& O销毁互斥锁之前，确保它已经被解锁。
' n7 R" [- H) L) J

pthread_mutex_destroy(&mutex);

  i( M& C9 M7 @6 ~2 V# g参数：mutex 是指向要销毁的 pthread_mutex_t 互斥锁对象的指针。
3 s- v! Q$ U- D& a* b* V  V返回值：
& O9 o: g1 J5 o6 w% Y

0：成功销毁。

EINVAL：互斥锁无效或未被初始化。

EBUSY：互斥锁仍被锁定，不能销毁。
( k! s4 k( \9 x* G4 e2 K* }: T% c6 r
销毁互斥锁后，它不能再被使用，除非重新初始化。
% M/ E  _8 p& h* Q3 s4 C# G5
互斥锁死锁问题
如果一个线程在锁定互斥锁后由于某种原因没有解锁（如忘记调用pthread_mutex_unlock()或在临界区中发生异常终止），其他线程将永远无法获得该锁，导致系统卡住。
0 r' k8 h$ W( p2 z7 u
以下例子中，线程 A 锁定 mutex1，线程 B 锁定 mutex2，接着 A 和 B 分别尝试锁定对方已经持有的互斥锁，导致相互等待，程序进入死锁状态。
& ?* c, f1 l$ U; J; G$ d

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
: J. B/ j" J8 Z) Ovoid *threadA(void *arg) {    pthread_mutex_lock(&mutex1);    sleep(1);  // 模拟工作    pthread_mutex_lock(&mutex2);  // 这里会发生死锁    pthread_mutex_unlock(&mutex2);    pthread_mutex_unlock(&mutex1);    return NULL;}
void *threadB(void *arg) {    pthread_mutex_lock(&mutex2);    sleep(1);  // 模拟工作    pthread_mutex_lock(&mutex1);  // 这里会发生死锁    pthread_mutex_unlock(&mutex1);    pthread_mutex_unlock(&mutex2);    return NULL;}
预防死锁方法：
3 `! z+ B4 w) ^5 b$ J6 k

固定锁顺序：所有线程在请求多个锁时，必须按照相同的顺序来请求。

超时加锁：使用 pthread_mutex_trylock()，可以避免线程长时间等待锁。
1 [% _& Z( _- P8 z4 U
7 J& w! a( C/ l4 T' c6
互斥锁的属性
# \( t$ M/ o1 H. x/ kpthread_mutexattr_t 结构体用于控制互斥锁的行为。常用属性包括互斥锁的类型。

通过 pthread_mutexattr_settype() 设置互斥锁的类型。
, f8 A2 c. K2 }
8 x; K/ `0 _5 Z% }常见类型包括：
4 P% Y: f1 s( h, `2 U! e2 n/ v

PTHREAD_MUTEX_NORMAL：普通互斥锁，不会检查错误，递归加锁会导致死锁。

PTHREAD_MUTEX_ERRORCHECK：错误检查互斥锁，如果同一线程重复加锁，返回 EDEADLK 错误。

PTHREAD_MUTEX_RECURSIVE：递归锁，允许同一线程对互斥锁多次加锁，但需要相同次数的解锁。

PTHREAD_MUTEX_DEFAULT：默认行为，通常与 PTHREAD_MUTEX_NORMAL 等价。


! ~3 o" f% b$ a5 P: x/ [% Q设置递归锁的示例：
. J- J9 ?% f) `' t3 _

pthread_mutex_t mutex;pthread_mutexattr_t attr;
. |5 v' G. H" J( H3 \4 Ppthread_mutexattr_init(&attr);  // 初始化属性pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);  // 设置递归锁类型pthread_mutex_init(&mutex, &attr);  // 初始化互斥锁
pthread_mutexattr_destroy(&attr);  // 销毁属性
' h, ~. K+ ]8 l返回值：

0：成功。

EINVAL：互斥锁属性无效。

" H4 G( d0 O, H9 m8 G- n9 C互斥锁的正确使用包括初始化、加锁、解锁和销毁。
  o# S+ s/ T$ B! N% H) L/ N
+ ?; u0 d3 @2 e3 L6 o4 b通过静态或动态方法初始化互斥锁，根据需求选择合适的锁类型，可以有效避免线程竞争和死锁问题。

wk4hm5gtvr0640625.jpg

% R6 U: v& m+ U& q% d! A

a2caaufsuf4640725.gif

5 Q7 G8 N! ]5 u3 Z点击阅读原文，更精彩~