Linux线程同步之读写锁（rwlock）

Bertha 。 2021-11-11 10:48 507阅读 0赞

读写锁和互斥量（互斥锁）很类似，是另一种线程同步机制，但不属于POSIX标准，可以用来同步同一进程中的各个线程。当然如果一个读写锁存放在多个进程共享的某个内存区中，那么还可以用来进行进程间的同步，

和互斥量不同的是：**互斥量会把试图进入已保护的临界区的线程都阻塞；然而读写锁会视当前进入临界区的线程和请求进入临界区的线程的属性来判断是否允许线程进入。**

相对互斥量只有加锁和不加锁两种状态，读写锁有三种状态：**读模式下的加锁，写模式下的加锁，不加锁**。

读写锁的使用规则：

*  只要没有写模式下的加锁，任意线程都可以进行读模式下的加锁；
 *  只有读写锁处于不加锁状态时，才能进行写模式下的加锁；

读写锁也称为共享\-独占（shared-exclusive）锁，当读写锁以读模式加锁时，它是以共享模式锁住，当以写模式加锁时，它是以独占模式锁住。**读写锁非常适合读数据的频率远大于写数据的频率从的应用中**。这样可以在任何时刻运行多个读线程并发的执行，给程序带来了更高的并发度。

需要提到的是：读写锁到目前为止仍然不是属于POSIX标准，本文讨论的读写锁函数都是有Open Group定义的的。例如下面是在我机器上，编译器是gcc version 4.4.6，关于读写锁的定义是包含在预处理命令中的：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#if defined \_\_USE\_UNIX98 || defined \_\_USE\_XOPEN2K  
2.    
3.  ... 读写锁相关函数声明...  
4.    
5.  \#endif

#### 1读写锁的初始化和销毁 ####

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* Initialize read-write lock  \*/  
2.   **int** pthread\_rwlock\_init (pthread\_rwlock\_t \*\_\_restrict \_\_rwlock,  
3.                                  \_\_const pthread\_rwlockattr\_t \*\_\_restrict \_\_attr);  
4.    
5.  /\* Destroy read-write lock \*/  
6.  **extern** **int** pthread\_rwlock\_destroy (pthread\_rwlock\_t \*\_\_rwlock);  
7.    
8.                                                 返回值：成功返回0，否则返回错误代码

上面两个函数分别由于读写锁的初始化和销毁。和互斥量，条件变量一样，如果读写锁是静态分配的，可以通过常量进行初始化，如下：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  pthread\_rwlock\_t rwlock = PTHREAD\_RWLOCK\_INITIALIZER;

也可以通过pthread\_rwlock\_init()进行初始化。对于动态分配的读写锁由于不能直接赋值进行初始化，只能通过这种方式进行初始化。pthread\_rwlock\_init()第二个参数是读写锁的属性，如果采用默认属性，可以传入空指针NULL。

那么当不在需要使用时及释放（自动或者手动）读写锁占用的内存之前，需要调用pthread\_rwlock\_destroy()进行销毁读写锁占用的资源。

#### 2读写锁的属性设置 ####

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* 初始化读写锁属性对象 \*/  
2.  **int** pthread\_rwlockattr\_init (pthread\_rwlockattr\_t \*\_\_attr);  
3.    
4.  /\* 销毁读写锁属性对象 \*/  
5.  **int** pthread\_rwlockattr\_destroy (pthread\_rwlockattr\_t \*\_\_attr);  
6.    
7.  /\* 获取读写锁属性对象在进程间共享与否的标识\*/  
8.  **int** pthread\_rwlockattr\_getpshared (\_\_const pthread\_rwlockattr\_t \* \_\_restrict \_\_attr,  
9.                                            **int** \*\_\_restrict \_\_pshared);  
10.   
11. /\* 设置读写锁属性对象，标识在进程间共享与否  \*/  
12. **int** pthread\_rwlockattr\_setpshared (pthread\_rwlockattr\_t \*\_\_attr, **int** \_\_pshared);  
13.   
14.                                                     返回值：成功返回0，否则返回错误代码

这个属性设置和互斥量的基本一样，具体可以参考互斥量的设 [置互斥量的属性设置][Link 1]

#### 3读写锁的使用 ####

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\* 读模式下加锁  \*/  
2.  **int** pthread\_rwlock\_rdlock (pthread\_rwlock\_t \*\_\_rwlock);  
3.    
4.  /\* 非阻塞的读模式下加锁  \*/  
5.  **int** pthread\_rwlock\_tryrdlock (pthread\_rwlock\_t \*\_\_rwlock);  
6.    
7.  \# ifdef \_\_USE\_XOPEN2K  
8.  /\*  限时等待的读模式加锁 \*/  
9.  **int** pthread\_rwlock\_timedrdlock (pthread\_rwlock\_t \*\_\_restrict \_\_rwlock,  
10.                                        \_\_const **struct** timespec \*\_\_restrict \_\_abstime);  
11. \# endif  
12.   
13. /\* 写模式下加锁  \*/  
14. **int** pthread\_rwlock\_wrlock (pthread\_rwlock\_t \*\_\_rwlock);  
15.   
16. /\* 非阻塞的写模式下加锁 \*/  
17. **int** pthread\_rwlock\_trywrlock (pthread\_rwlock\_t \*\_\_rwlock);  
18.   
19. \# ifdef \_\_USE\_XOPEN2K  
20. /\* 限时等待的写模式加锁 \*/  
21. **int** pthread\_rwlock\_timedwrlock (pthread\_rwlock\_t \*\_\_restrict \_\_rwlock,  
22.                                        \_\_const **struct** timespec \*\_\_restrict \_\_abstime);  
23. \# endif  
24.   
25. /\* 解锁 \*/  
26. **int** pthread\_rwlock\_unlock (pthread\_rwlock\_t \*\_\_rwlock);  
27.   
28.                                                    返回值：成功返回0，否则返回错误代码

**（1）pthread\_rwlock\_rdlock()系列函数**

pthread\_rwlock\_rdlock()用于以读模式即共享模式获取读写锁，如果读写锁已经被某个线程以读模式占用，那么调用线程就被阻塞。在实现读写锁的时候可以对共享模式下锁的数量进行限制（目前不知如何限制）。

pthread\_rwlock\_tryrdlock()和pthread\_rwlock\_rdlock()的唯一区别就是，在无法获取读写锁的时候，调用线程不会阻塞，会立即返回，并返回错误代码EBUSY。

pthread\_rwlock\_timedrdlock()是限时等待读模式加锁，时间参数struct timespec \* \_\_restrict \_\_abstime也是绝对时间，和条件变量的pthread\_cond\_timedwait()使用基本一致，具体可以参考pthread\_cond\_timedwait()[ 3条件变量的使用][3]

**（2）pthread\_rwlock\_wrlock()系列函数**

pthread\_rwlock\_wrlock()用于写模式即独占模式获取读写锁，如果读写锁已经被其他线程占用，不论是以共享模式还是独占模式占用，调用线程都会进入阻塞状态。

pthread\_rwlock\_trywrlock()在无法获取读写锁的时候，调用线程不会进入睡眠，会立即返回，并返回错误代码EBUSY。

pthread\_rwlock\_timedwrlock()是限时等待写模式加锁，也和条件变量的pthread\_cond\_timedwait()使用基本一致，具体可以参考pthread\_cond\_timedwait()[3条件变量的使用。][3]

**（3）pthread\_rwlock\_unlock()**

无论以共享模式还是独占模式获得的读写锁，都可以通过调用pthread\_rwlock\_unlock()函数进行释放该读写锁。

下面是测试代码：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <iostream>  
2.  \#include <cstdlib>  
3.    
4.  \#include <unistd.h>  
5.  \#include <pthread.h>  
6.    
7.  **using** **namespace** std;  
8.    
9.  **struct**\{  
10.     pthread\_rwlock\_t rwlock;  
11.     **int** product;  
12. \}sharedData = \{PTHREAD\_RWLOCK\_INITIALIZER, 0\};  
13.   
14. **void** \* produce(**void** \*ptr)  
15. \{  
16.     **for** (**int** i = 0; i < 5; ++i)  
17.     \{  
18.         pthread\_rwlock\_wrlock(&sharedData.rwlock);  
19.         sharedData.product = i;  
20.         pthread\_rwlock\_unlock(&sharedData.rwlock);  
21.   
22.         sleep(1);  
23.     \}  
24. \}  
25.   
26. **void** \* consume1(**void** \*ptr)  
27. \{  
28.     **for** (**int** i = 0; i < 5;)  
29.     \{  
30.         pthread\_rwlock\_rdlock(&sharedData.rwlock);  
31.         cout<<"consume1:"<<sharedData.product<<endl;  
32.         pthread\_rwlock\_unlock(&sharedData.rwlock);  
33.   
34.         ++i;  
35.         sleep(1);  
36.     \}  
37. \}  
38.   
39. **void** \* consume2(**void** \*ptr)  
40. \{  
41.     **for** (**int** i = 0; i < 5;)  
42.     \{  
43.         pthread\_rwlock\_rdlock(&sharedData.rwlock);  
44.         cout<<"consume2:"<<sharedData.product<<endl;  
45.         pthread\_rwlock\_unlock(&sharedData.rwlock);  
46.   
47.         ++i;  
48.         sleep(1);  
49.     \}  
50. \}  
51.   
52. **int** main()  
53. \{  
54.     pthread\_t tid1, tid2, tid3;  
55.   
56.     pthread\_create(&tid1, NULL, produce, NULL);  
57.     pthread\_create(&tid2, NULL, consume1, NULL);  
58.     pthread\_create(&tid3, NULL, consume2, NULL);  
59.   
60.     **void** \*retVal;  
61.   
62.     pthread\_join(tid1, &retVal);  
63.     pthread\_join(tid2, &retVal);  
64.     pthread\_join(tid3, &retVal);  
65.   
66.     **return** 0;  
67. \}

测试结果如下：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  consume1:0  
2.  consume2:0  
3.  consume2:0  
4.  consume1:1  
5.  consume2:1  
6.  consume1:2  
7.  consume2:2  
8.  consume1:3  
9.  consume2:3  
10. consume1:4

如果把consume1的解锁注释掉，如下：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void** \* consume1(**void** \*ptr)  
2.  \{  
3.      **for** (**int** i = 0; i < 5;)  
4.      \{  
5.          pthread\_rwlock\_rdlock(&sharedData.rwlock);  
6.          cout<<"consume1:"<<sharedData.product<<endl;  
7.          //pthread\_rwlock\_unlock(&sharedData.rwlock);  
8.    
9.          ++i;  
10.         sleep(1);  
11.     \}  
12. \}

程序的执行结果如下：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  consume1:0  
2.  consume2:0  
3.  consume2:0  
4.  consume1:0  
5.  consume2:0  
6.  consume1:0  
7.  consume2:0  
8.  consume1:0  
9.  consume2:0  
10. consume1:0

从执行结果可以看出Linux 2.6.18提供的读写锁函数是优先考虑等待读模式占用锁的线程，这种实现的一个很大缺陷就是出现写入线程饿死的情况。

[view plain]: http://blog.csdn.net/anonymalias/article/details/9174595#
[Link 1]: http://blog.csdn.net/anonymalias/article/details/9174403
[3]: http://blog.csdn.net/anonymalias/article/details/9174481