【Linux】旋转锁 | 读写锁
慕雪年华

在之前的线程学习中,用到的锁都是挂起等待锁,如果申请不到锁,那就会在锁中等待;

自旋锁则不大相似

[TOC]

1.自旋锁

1.1 概念

自旋锁是一个轮询检测锁,其检测机制并不是挂起等待,而是不断的询问锁有没有空闲;类似于一个while(1)循环的trylock()

由于其需要不断的轮询检测,所以会占用一定的CPU资源;如果线程较多,就容易给cpu造成负荷。

但是自旋锁无须唤醒挂起等待状态的线程,其消耗较小。

总结一下:

  • 自旋锁适合竞争不激烈,且临界区较小(呆的时间短)的情况
  • 自旋锁不适合大量线程,临界区长的情况

自旋锁的优缺点反过来,便是挂起等待锁的优缺点了。我们要根据不同场景,正确选择锁的类型

1.2 接口

相关接口和mutex都是很相似的,这里就不演示使用的效果了

1.2.1 pthread_spin_init/destroy

1
2
3
4
#include <pthread.h>

int pthread_spin_destroy(pthread_spinlock_t *lock);
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);

1.2.2 pthread_spin_lock

自旋锁同样有trylock接口,用于判断锁是否就绪

1
2
3
#include <pthread.h>
int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);

1.2.3 pthread_spin_unlock

1
2
#include <pthread.h>
int pthread_spin_unlock(pthread_spinlock_t *lock);

2.读写锁

有的时候,我们会有一份config配置文件,这个配置文件会有非常多的线程进行读取,但是很少进行修改和写入。

此时我们如果对配置文件的读取进行加锁,就容易导致效率问题,众多线程不断被阻塞,产生性能损失。

此时,就可以用一个专门的读写锁,对读者和写者加不同的锁,在提升读取性能的同时,保证写入不冲突

2.1 读者写者的关系

写着和写着之间不用多说,肯定是互斥关系;

读者和写者之间也是互斥关系,在写入的时候,不能进行读取,否则容易出现二义性问题;

  • 写者写入了一个a,线程甲来读取,得到的结果是a
  • 写者继续写入了b,线程乙来读取,得到的结果是ab

这是因为写者的写入还没有完成,导致甲乙读者会获取到完全不同的结果,这是不对的;

读者和读者之间没有关系,因为读者并不会修改数据,也不会取走数据,其存在对临界资源没有影响。


2.2 接口

2.2.1 init/destroy

读写锁只需要初始一个锁就行了,无须对读者写者初始化两个不同的锁

1
2
3
4
5
#include <pthread.h>

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
const pthread_rwlockattr_t *restrict attr);

2.2.2 读者加锁

读写锁的读者锁/写者锁是分开的,我们要针对不同的线程调用不同的锁

1
2
3
4
#include <pthread.h>

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

但是解锁的接口是一样的

1
2
#include <pthread.h>
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

2.2.3 写者加锁

1
2
3
#include <pthread.h>
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

2.2.4 设置锁的属性

参考 PTHREAD_RWLOCKATTR_SETKIND_NP - Linux手册页

读写锁可以允许我们设置是读者优先还是写者优先。如果采用默认的属性,可能会出现读者一直在读,写者没有办法写入的情况(打印错位是正常情况)

1
2
3
4
5
6
7
8
9
10
11
[muxue@bt-7274:~/git/linux/code/23-01-20 rwlock]$ ./test
reader [140484801697536]
reader [140484801697536] 0
reader [140484793304832]
reader [reader [140484784912128140484793304832]
reader [140484784912128] 0
] 0
reader [140484759734016]
reader [140484759734016] 0
reader [140484776519424]

此时就出现了写者饥饿问题,写者无法访问临界资源,饿死了😂

我们可以根据自己的需求进行设置读写锁的属性

1
2
3
4
5
6
7
8
int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *attr, int pref); 
/*
pref 共有 3 种选择
PTHREAD_RWLOCK_PREFER_READER_NP (默认设置) 读者优先,可能会导致写者饥饿情况
PTHREAD_RWLOCK_PREFER_WRITER_NP 写者优先,目前有 BUG,导致表现行为和
PTHREAD_RWLOCK_PREFER_READER_NP 一致
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 写者优先,但写者不能递归加锁,避免死锁
*/

下面是一个示例

1
2
3
4
5
pthread_rwlock_t rwlock;//锁
pthread_rwlockattr_t attr;//属性
pthread_rwlockattr_init(&attr);//初始化属性
pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);//设置锁的属性为写者优先
pthread_rwlock_init(&rwlock, &attr);//初始化并设置读写锁的属性

2.3 代码

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
#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

volatile int board = 0;//临界资源

pthread_rwlock_t rw;//全局读写锁

void *reader(void* args)
{
const char *name = static_cast<const char *>(args);
cout << "reader ["<<pthread_self() <<"]"<< endl;
//sleep(1);
while(true)
{
pthread_rwlock_rdlock(&rw);
cout << "reader ["<<pthread_self() <<"] " << board << endl;
pthread_rwlock_unlock(&rw);
usleep(110);
}
}

void *writer(void *args)
{
const char *name = static_cast<const char *>(args);
//sleep(1);
while(true)
{
pthread_rwlock_wrlock(&rw);
board++;
cout << "writer [" << pthread_self() <<"]"<< endl;
pthread_rwlock_unlock(&rw);
usleep(100);
}
}

int main()
{
pthread_rwlock_init(&rw, nullptr);
pthread_t r1,r2,r3,r4,r5,r6, w1,w2;
pthread_create(&r1, nullptr, reader, (void*)"reader");
pthread_create(&r2, nullptr, reader, (void*)"reader");
pthread_create(&r3, nullptr, reader, (void*)"reader");
pthread_create(&r4, nullptr, reader, (void*)"reader");
pthread_create(&r5, nullptr, reader, (void*)"reader");
pthread_create(&r6, nullptr, reader, (void*)"reader");
pthread_create(&w1, nullptr, writer, (void*)"writer");
pthread_create(&w2, nullptr, writer, (void*)"writer");


pthread_join(r1, nullptr);
pthread_join(r2, nullptr);
pthread_join(r3, nullptr);
pthread_join(r4, nullptr);
pthread_join(r5, nullptr);
pthread_join(r6, nullptr);
pthread_join(w1, nullptr);
pthread_join(w2, nullptr);

pthread_rwlock_destroy(&rw);
return 0;
}

运行结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
reader [140067523458816] 7086
reader [140067548636928] 7086
writer [140067515066112]
writer [140067506673408]
reader [140067540244224] 7088
reader [140067565422336] 7088
reader [140067557029632] 7088
reader [140067531851520] 7088
reader [140067523458816] 7088
writer [140067515066112]
writer [140067506673408]
reader [140067548636928] 7090
writer [140067515066112]
reader [140067523458816] 7091
writer [140067506673408]
reader [140067548636928] 7092
reader [140067557029632] 7092

可以看到读者的线程较多,且能够正确读取数据。

如果在读者的whiile中加上sleep(10)

1
2
3
4
5
6
7
8
9
10
11
12
13
void *reader(void* args)
{
const char *name = static_cast<const char *>(args);
cout << "reader ["<<pthread_self() <<"]"<< endl;
while(true)
{
pthread_rwlock_rdlock(&rw);
cout << "reader ["<<pthread_self() <<"] " << board << endl;
sleep(10);//睡
pthread_rwlock_unlock(&rw);
usleep(110);//避免出现只有一个线程工作
}
}

能够看到多个读者之间不冲突,不会出现读者A申请锁后,读者B就无法访问临界区的情况。如果是互斥锁,读者A申请之后进入休眠,B就无法申请该锁。

image