Linux应用开发 - 读写锁

Linux应用开发 - 读写锁

什么时候用到读写锁：多线程开发中，如果少数线程会对共享内存数据修改，多数线程只是读取共享数据的值，就适用于读写锁解决“线程间抢夺资源”的问题。

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

当有多个线程发出读请求时，这些线程可以同时执行，也就说，共享数据的值可以同时被多个发出读请求的线程获取，当有多个线程发出写请求时，这些线程只能同步执行（互斥）。

---

本质读写锁就是一个全局变量

当读写锁发出读请求的线程占用时，称为读锁；当读写锁发出写请求的线程占用时，称为写锁

读写锁非常适合读数据的频率远大于写数据的频率从的应用中，这样可以在任何时刻运行多个读线程并发的执行，给程序带来了更高的并发度。

读写锁允许发出“读”请求的线程共享资源，发出“写”请求的线程必须独占资源，进而实现线程同步。

具体用法

读写锁用 pthread_rwlock_t 类型的变量表示，此类型定义在头文件中

pthread_rwlock_t myRWLock;
1

• 初始化读写锁

  • /*第一种*/
    pthread_rwlock_t myRWLock = PTHREAD_RWLOCK_INITIALIZER;
    1
    2

  • /*第二种*/
    int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
    1
    2

    • rwlock：初始化的读写锁变量
    • attr：用于自定义读写锁变量的属性，置为 NULL 时表示以默认属性初始化读写锁。
    • 返回值：成功：0；失败：非零数

• 读锁

  • int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock);
    int pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock);
    1
    2

    • pthread_rwlock_rdlock() 函数会阻塞当前线程，直至读写锁被释放；
    • pthread_rwlock_tryrdlock() 函数不会阻塞当前线程，直接返回 EBUSY。

• 写锁

  • int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);
    int pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock);
    1
    2

    • 当读写锁处于“无锁”状态时，两个函数都能成功获得写锁；当读写锁处于“读锁”或“写锁”状态时：

    • pthread_rwlock_wrlock() 函数会阻塞当前线程，直至读写锁被释放；

    • pthread_rwlock_trywrlock() 函数不会阻塞线程，直接返回 EBUSY。

• 释放读写锁

  无论是处于“无锁”、“读锁”还是“写锁”的读写锁，都可以使用如下函数释放读写锁

  • int pthread_rwlock_unlock (pthread_rwlock_t* rwlock);
    1

    • 由于多个线程可以同时获得“读锁”状态下的读写锁，这种情况下一个线程释放读写锁后，读写锁仍处于“读锁”状态，直至所有线程都释放读写锁，读写锁的状态才为“无锁”状态。

• 销毁读写锁

  • int pthread_rwlock_destroy(pthread_rwlock_t* rwlock);
    1

    • 返回值：成功：0；失败：非零数

案例

#include 
#include 
#include 
int x = 0;
//创建读写锁变量
pthread_rwlock_t myrwlock;

void* read_thread(void* args){
    printf("------%u read_thread ready\n",pthread_self());
    while (1)
    {
        sleep(1);
        //请求读锁
        pthread_rwlock_rdlock(&myrwlock);
        printf("read_thread: %u,x=%d\n", pthread_self(), x);
        sleep(1);
        //释放读写锁
        pthread_rwlock_unlock(&myrwlock);
    }
    return NULL;
}

void* write_thread(void* param)
{
    printf("------%u write_thread ready!\n",pthread_self());
    while (1)
    {
        sleep(1);
        // 请求写锁
        pthread_rwlock_wrlock(&myrwlock);
        ++x;
        printf("write_thread: %u,x=%d\n", pthread_self(), x);
        sleep(1);
        //释放读写锁
        pthread_rwlock_unlock(&myrwlock);
    }
    return NULL;
}

int main()
{
    int i;
    //初始化读写锁
    pthread_rwlock_init(&myrwlock, NULL);
    //创建 3 个读 x 变量的线程
    pthread_t readThread[3];
    for (i = 0; i < 3; ++i)
    {
        pthread_create(&readThread[i], NULL, read_thread, NULL);
    }
    //创建 1 个修改 x 变量的线程
    pthread_t writeThread;
    pthread_create(&writeThread, NULL, write_thread, NULL);
    //等待各个线程执行完成
    pthread_join(writeThread, NULL);

    for (int i = 0; i < 3; ++i)
    {
        pthread_join(readThread[i], NULL);
    }
    //销毁读写锁
    pthread_rwlock_destroy(&myrwlock);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

运行结果：

------2450659072 write_thread ready!
------2459051776 read_thread ready
------2475837184 read_thread ready
------2467444480 read_thread ready
write_thread: 2450659072,x=1
read_thread: 2459051776,x=1
read_thread: 2467444480,x=1
read_thread: 2475837184,x=1
write_thread: 2450659072,x=2
read_thread: 2459051776,x=2
read_thread: 2467444480,x=2
read_thread: 2475837184,x=2
1
2
3
4
5
6
7
8
9
10
11
12

一共是四个线程（三个读锁线程，一个写锁线程）

读取x变量，读取变量前会先获得读锁。写锁用于修改x变量的值，修改前先获得写锁

执行结果中三个读取x变量的线程总是能够获得x变量的值，因为能够同时过得读锁并同时执行