【Linux】：多线程（读写锁 && 自旋锁）
✨ 倘若南方知我意，莫将晚霞落黄昏 🌏
📃个人主页：island1314
🔥个人专栏：Linux—登神长阶
⛺️ 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞
目录
1. 读写锁 🔏
1.1 基本概念
1.2 读写锁的工作原理及特点
1.3 读写锁的实现
🥝 读写锁相关函数
🥝 案例如下：
1.4 读写锁优缺点及应用场景
🍉 优点：
🍉 缺点：
🍉 读写锁应用场景：
1.5 性能开销：读写锁 VS 互斥锁
2. 自旋锁 🔐
2.1 基本概念
2.2 自旋锁的原理
2.3 自旋锁实现
2.4 自旋锁优缺点及应用场景
🥑 优点：
🥑 缺点：
🥑使用场景：
2.5 自旋锁 VS 互斥锁
1. 读写锁 🔏
1.1 基本概念
🔥 读写锁（Read-Write Lock）是一种用于多线程环境下同步访问共享资源的锁。它与传统的互斥锁（Mutex）有所不同，提供了更细粒度的控制，以便提高并发性能。它允许多个线程同时 读取 数据，但在写入数据时，必须确保只有一个线程可以进行写操作，并且在写操作期间，所有的读操作都必须等待。
💧 读写锁的核心思想是：读操作之间是可以并发执行的，而写操作是独占的，即不能与其他读操作或者写操作同时执行
1.2 读写锁的工作原理及特点
- 即读锁允许多个线程同时获得，因为读操作本身是线程安全的；而写锁则是互斥锁，不允许多个线程同时获得写锁，并且写操作和读操作也是互斥的
🐇 读写锁的特点：
- 读读不互斥：多个读线程可以同时访问共享资源
- 读写互斥：读操作和写操作互斥，即在写操作进行时，其他线程不能进行读或写操作
- 写写互斥：多个写线程不能同时进行写操作
🐇 具体来说，读写锁的行为如下：
-
读操作（共享锁）：
- 如果没有线程正在持有写锁，那么多个线程可以同时获得读锁并执行读取操作。
- 读操作不会阻塞其他读操作，但会阻塞写操作。
-
写操作（独占锁）：
- 写操作会阻塞所有其他的读操作和写操作。换句话说，在某个线程持有写锁期间，其他线程既无法获得读锁也无法获得写锁。
- 写操作是独占的，确保在操作过程中共享数据的一致性
1.3 读写锁的实现
🥝 读写锁相关函数
在书写具体代码之前，我们先来了解一下其相关函数
① 初始化锁
原型：
int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
参数：
rwlock: 指向 pthread_rwlock_t 类型的读写锁对象的指针。
attr: 一个指向 pthread_rwlockattr_t 类型的指针，可以设置锁的属性。
如果不需要特定的属性，通常可以将其设置为 NULL。
返回值：
返回 0 表示成功，返回错误码（如 EINVAL）表示初始化失败。
范例：
#include
#include
pthread_rwlock_t rwlock;
int main() {
// 初始化读写锁
if (pthread_rwlock_init(&rwlock, NULL) != 0) {
perror("pthread_rwlock_init");
return 1;
}
// 后续可以使用 rwlock 执行读写操作
// 销毁读写锁
pthread_rwlock_destroy(&rwlock);
return 0;
}
🎈 pthread_rwlock_init 用于初始化一个读写锁。该函数会创建一个 pthread_rwlock_t 类型的读写锁变量，使其处于初始化状态，供后续的线程操作使用
② 获取锁
a. 读锁
原型：
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
参数：
rwlock: 指向要获取读锁的 pthread_rwlock_t 类型的读写锁对象。
返回值：
返回 0 表示成功，返回错误码表示失败（例如 EBUSY 表示写锁被持有，当前线程无法获得读锁）
范例：
#include
#include
pthread_rwlock_t rwlock;
void* read_data(void* arg) {
pthread_rwlock_rdlock(&rwlock); // 获取读锁
printf("Reading data...
");
pthread_rwlock_unlock(&rwlock); // 释放读锁
return NULL;
}
int main() {
// 初始化读写锁
pthread_rwlock_init(&rwlock, NULL);
pthread_t threads[3];
for (int i = 0; i < 3; i++) {
pthread_create(&threads[i], NULL, read_data, NULL);
}
for (int i = 0; i < 3; i++) {
pthread_join(threads[i], NULL);
}
pthread_rwlock_destroy(&rwlock); // 销毁读写锁
return 0;
}
// 在上述代码中，多个线程可以同时获得读锁并执行读取操作，而无需相互阻塞。 🎈 pthread_rwlock_rdlock 用于获取读锁，即共享锁。多个线程可以同时持有读锁进行读取操作，但在任何时刻，写锁无法被获得，直到所有的读锁都被释放。
b. 写锁
原型：
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
参数：
rwlock: 指向要获取写锁的 pthread_rwlock_t 类型的读写锁对象。
返回值：
返回 0 表示成功，返回错误码表示失败如: EBUSY 表示有其他线程持有读锁或写锁，当前线程无法获得写锁
范例：
#include
#include
pthread_rwlock_t rwlock;
void* write_data(void* arg) {
pthread_rwlock_wrlock(&rwlock); // 获取写锁
printf("Writing data...
");
pthread_rwlock_unlock(&rwlock); // 释放写锁
return NULL;
}
int main() {
// 初始化读写锁
pthread_rwlock_init(&rwlock, NULL);
pthread_t threads[2];
for (int i = 0; i < 2; i++) {
pthread_create(&threads[i], NULL, write_data, NULL);
}
for (int i = 0; i < 2; i++) {
pthread_join(threads[i], NULL);
}
pthread_rwlock_destroy(&rwlock); // 销毁读写锁
return 0;
}
// 在上面的示例中，write_data 函数每次都获取写锁，并在完成写操作后释放写锁。
// 在写操作期间，不允许其他线程获取读锁或写锁 🎈 pthread_rwlock_wrlock 用于获取写锁。写锁是独占的，即任何一个线程持有写锁时，其他线程不能获得读锁或写锁。只有当所有线程都释放了读锁，写锁才能被获取。
③ 释放锁
原型：
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
参数：
rwlock: 指向需要释放锁的 pthread_rwlock_t 类型的读写锁对象。
返回值：
返回 0 表示成功，返回错误码表示失败（例如 EINVAL 表示锁没有被当前线程持有）🎈 每当一个线程完成对共享资源的读或写操作时，它需要释放相应的锁。pthread_rwlock_unlock 用于释放由 pthread_rwlock_rdlock 或 pthread_rwlock_wrlock 获得的锁。
🥝 案例如下：
#include
#include
#include
#include
#include
#include
// 共享资源
int shared_data = 0;
// 读者锁
pthread_rwlock_t rwlock;
// 读者线程函数
void *Reader(void *arg)
{
// slee(1); // 读者优先， 一旦读者进入 && 读者很多，写者就进不去了
int number = *(int*)arg;
while(true)
{
pthread_rwlock_rdlock(&rwlock); // 读者加锁
std::cout << "读者- " << number << " 正在读取数据, 数据是: " << shared_data << std::endl;
sleep(1); // 模拟读取操作
pthread_rwlock_unlock(&rwlock); // 解锁
}
delete (int*)arg;
return NULL;
}
// 写者线程函数
void *Writer(void *arg)
{
int number = *(int*)arg;
while(true)
{
pthread_rwlock_wrlock(&rwlock); // 写者加锁
shared_data = rand() % 100; // 修改共享数据
std::cout << "写者- " << number << " 正在写入, 新的数据是: " << shared_data << std::endl;
sleep(2); // 模拟写入操作
pthread_rwlock_unlock(&rwlock); // 解锁
}
delete (int*)arg;
return NULL;
}
int main()
{
srand(time(nullptr)^getpid());
pthread_rwlock_init(&rwlock, NULL); // 初始化读写锁
// 可以提高读写数量配比，观察现象
const int reader_num = 2;
const int writer_num = 2;
const int total = reader_num + writer_num;
pthread_t threads[total]; // 假设读者和写者数量相等
// 创建读者线程
for(int i = 0; i < reader_num; ++i)
{
int *id = new int(i);
pthread_create(&threads[i], NULL, Reader, id);
}
// 创建写者线程
for(int i = reader_num; i < total; ++i)
{
int *id = new int(i - reader_num);
pthread_create(&threads[i], NULL, Writer, id);
}
// 等待所有线程完成
for(int i = 0; i < total; ++i)
{
pthread_join(threads[i], NULL);
}
pthread_rwlock_destroy(&rwlock); // 销毁读写锁
return 0;
} 输出结果如下：
分析：
- 上面我们创建了 两个读者、两个写者，读者线程每次获取读锁并且读取数据后休眠一秒，而写者线程每次获取写锁后休眠 2 s，这种不对称休眠可能会使写者长时间处于等待
- 写锁，它是独占的，意味着任何时候只能有 一个线程 获得写锁。即使你创建了两个写者线程，只有一个线程能在某一时刻获得写锁，另一个线程必须等待，直到当前持有写锁的线程释放它。
- 因此大部分情况，我们都只看到读锁读取数据，少部分情况出现写锁写入
那么我们做出一些修改，比如让读锁在加锁前就休眠 1 s
则出现大部分情况都是写者正在写入，读者很难读取到
同样地，我们也可以修改读者、写者数量来改变输出情况，大家也可以自己试试，我就不多尝试了
1.4 读写锁优缺点及应用场景
🍉 优点：
- 并发性：读操作的并发执行大大提高了系统的吞吐量，尤其是当读操作远多于写操作时，读写锁能够显著提高性能。
- 资源共享：多个线程可以在不干扰彼此的情况下同时读取共享资源，提高了资源利用率。
🍉 缺点：
虽然读写锁提高了并发性能，但它也有一些潜在的缺点：
-
写操作的饥饿问题：如果系统中有大量的读操作而写操作很少发生，可能会导致写线程长期得不到执行。这种现象被称为写操作的 饥饿（starvation）。一些实现会通过公平策略来解决这个问题。
-
实现复杂性：相比普通的互斥锁，读写锁的实现更复杂，需要管理多个线程的访问请求，可能会导致死锁或者性能下降，尤其是在高并发环境下。
-
性能瓶颈：在某些场景下，读写锁的性能提升可能并不显著，特别是在写操作占主导地位时，锁的争用可能导致性能瓶颈
🍉 读写锁应用场景：
- 读操作频繁，写操作较少：如果你的应用中读操作远多于写操作，使用读写锁可以显著提高性能，因为多个线程可以同时执行读操作，而写操作则需要独占锁，避免了不必要的阻塞。示例：数据库缓存、Web 服务器的请求处理等。
- 不需要严格顺序的读操作：读操作之间不需要顺序或依赖关系时，多个线程可以并发执行读操作，提高并发性。
1.5 性能开销：读写锁 VS 互斥锁
- 读写锁的性能开销与普通互斥锁相比，通常情况下读写锁的单次加锁开销大于互斥锁。
- 这是因为读写锁需要进行额外的引用计数和加锁读写性质判别，这些操作增加了其复杂性和性能开销。
- 在设计上，读写锁比互斥锁更复杂，其内部加锁和解锁的逻辑也更为复杂，需要更新读者和写者的数量，而互斥锁则无需这样的操作。
- 然而，读写锁的性能优势在于其在读多写少的场景下表现更佳。
- 当读操作远多于写操作时，读写锁可以允许多个读线程同时访问共享资源，从而提高并发性能。
- 相反，在写操作频繁的情况下，读写锁的性能会比互斥锁差，因为写操作必须互斥进行，读写锁需要处理额外的逻辑来避免写锁“饥饿”
1.6 优先策略
🦋 读者优先（Reader-Preference）
- 在这种策略中， 系统会尽可能多地允许多个读者同时访问资源（比如共享文件或数据） ， 而不会优先考虑写者。 这意味着当有读者正在读取时， 新到达的读者会立即被允许进入读取区， 而写者则会被阻塞， 直到所有读者都离开读取区。 读者优先策略可能会导致写者饥饿（即写者长时间无法获得写入权限） ， 特别是当读者频繁到达时。
🦋 写者优先（Writer-Preference）
- 在这种策略中， 系统会优先考虑写者。 当写者请求写入权限时， 系统会尽快地让写者进入写入区， 即使此时有读者正在读取。 这通常意味着一旦有写者到达， 所有后续的读者都会被阻塞， 直到写者完成写入并离开写入区。 写者优先策略可以减少写者等待的时间， 但可能会导致读者饥饿（即读者长时间无法获得读取权限） ， 特别是当写者频繁到达时。
2. 自旋锁 🔐
2.1 基本概念
🔥 自旋锁（Spinlock）是一种简单的同步机制，用于在多线程或多核系统中防止并发访问共享资源。在获取锁时，如果锁被其他线程占用，线程并不会进入休眠状态，而是不断地重复检查锁是否可用，这个过程就被称为“自旋”
2.2 自旋锁的原理
🐳 自旋锁通常使用一个共享的标志位(如一个布尔值)来表示锁的状态。当标志位为true 时，表示锁已被某个线程占用;当标志位为false 时，表示锁可用。当一个线程尝试获取自旋锁时，它会不断检查标志位:
如果标志位为 false，表示锁可用，线程将设置标志位为true，表示自己占用了锁，并进入临界区。
如果标志位为 true(即锁已被其他线程占用)，线程会在一个循环中不断自旋等待，直到锁被释放。
2.3 自旋锁实现
自旋锁的实现通常使用原子操作来保证操作的原子性，常用的软件实现方式是通过 CAS（Compare-And-Swap）指令实现。以下是一个简单的自旋锁实现示例（伪代码）：
#include
#include
#include
#include
// 使用原子标志来模拟自旋锁
atomic_flag spinlock = ATOMIC_FLAG_INIT; // ATOMIC_FLAG_INIT 是 0
// 尝试获取锁
void spinlock_lock() {
while (atomic_flag_test_and_set(&spinlock)) {
// 如果锁被占用，则忙等待
}
}
// 释放锁
void spinlock_unlock() {
atomic_flag_clear(&spinlock);
}
typedef _Atomic struct
{
#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
_Bool __val;
#else
unsigned char __val;
#endif
}atomic_flag; 功能描述
- atomic_flag_test_and_set 函数检查 atomic_flag 的当前状态。
- 如果atomic_flag 之前没有被设置过（即其值为 false 或“未设置”状态），则函数会将其设置为 true（或“设置”状态），并返回先前的值（在这种情况下为 false）。
- 如果atomic_flag 之前已经被设置过（即其值为 true），则函数不会改变其状态，但会返回 true。
原子性
- 这个操作是原子的，意味着在多线程环境中，它保证了对 atomic_flag 的读取和修改是不可分割的。当一个线程调用此函数时，其他线程无法看到这个操作的任何中间状态，这确保了操作的线程安全性。
Linux 提供的自旋锁系统调用
#include
int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
int pthread_spin_destroy(pthread_spinlock_t *lock); 注意事项
- 使用自旋锁时，需要确保锁被释放的时间尽可能短，以避免 CPU 资源的浪费。
- 在多 CPU 环境下，自旋锁可能不如其他锁机制高效，因为它可能导致线程在不同的 CPU 上自旋等待。
结论
- 自旋锁是一种适用于短时间内锁竞争情况的同步机制，它通过减少线程切换的开销来提高锁操作的效率。然而，它也存在 CPU 资源浪费和可能引起活锁等缺点。
- 在使用自旋锁时，需要根据具体的应用场景进行选择，并确保锁被释放的时间尽可能短。
案例： 抢票卖票
#include
#include
#include
#include
int ticket = 1000;
pthread_spinlock_t lock;
void *routine(void *arg)
{
char *id = (char*)arg;
while(1){
if (ticket > 0){
usleep(1000);
printf("%s sells ticket:%d
", id, ticket);
ticket--;
}
else{
break;
}
}
return nullptr;
}
int main(){
pthread_t t1, t2, t3, t4;
pthread_create(&t1, NULL, routine, (void *) "thread-1");
pthread_create(&t2, NULL, routine, (void *) "thread-2");
pthread_create(&t3, NULL, routine, (void *) "thread-3");
pthread_create(&t4, NULL, routine, (void *) "thread-4");
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_join(t3, NULL);
pthread_join(t4, NULL);
return 0;
} 还记得我们之前写的买票问题嘛，这个最后由于竞争问题，导致最后会出现负值，如下：
加上自旋锁，修改如下：
#include
#include
#include
#include
int ticket = 1000;
pthread_spinlock_t lock;
void *routine(void *arg)
{
char *id = (char*)arg;
while(1)
{
pthread_spin_lock(&lock);
if (ticket > 0)
{
usleep(1000);
printf("%s sells ticket:%d
", id, ticket);
ticket--;
pthread_spin_unlock(&lock);
}
else{
pthread_spin_unlock(&lock);
break;
}
}
return nullptr;
}
int main()
{
pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);
pthread_t t1, t2, t3, t4;
pthread_create(&t1, NULL, routine, (void *) "thread-1");
pthread_create(&t2, NULL, routine, (void *) "thread-2");
pthread_create(&t3, NULL, routine, (void *) "thread-3");
pthread_create(&t4, NULL, routine, (void *) "thread-4");
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_join(t3, NULL);
pthread_join(t4, NULL);
return 0;
} 相比于之前的互斥锁，这里我们把 加锁放到了 while 循环内部，因为需要一直自检锁，此时结果如下：
2.4 自旋锁优缺点及应用场景
🥑 优点：
- 高效的短期锁竞争：如果锁持有时间很短，自旋锁可以非常高效，因为它避免了线程上下文切换的开销。
- 实现简单：自旋锁的实现通常非常简单，基本上只需要一个标志位（flag）和原子操作
- 低延迟：自旋锁适用于短时间内的锁竞争情况，因为它不会让线程进入休眠状
态，从而避免了线程切换的开销，提高了锁操作的效率。 - 减少系统调度开销：等待锁的线程不会被阻塞，不需要上下文切换，从而减少了
系统调度的开销
🥑 缺点：
- 高 CPU 使用率：如果线程需要等待很长时间才能获取锁，自旋锁会造成 CPU 时间片的浪费，因为线程会在忙等期间占用 CPU 资源。
- 可能导致优先级反转：如果一个低优先级的线程持有锁，而高优先级线程自旋等待，会造成优先级反转的问题（此问题可以通过其他技术如优先级继承来解决）。
- 不适用于长时间锁持有：如果锁的持有时间较长，自旋锁并不适合，因为自旋等待会导致极大的性能问题
- 可能引起活锁：当多个线程同时自旋等待同一个锁时，如果没有适当的退避策略，可能会导致所有线程都在不断检查锁状态而无法进入临界区，形成活锁
🥑使用场景：
- 短暂等待的情况：适用于锁被占用时间很短的场景，如多线程对共享数据进行简单的读写操作。
- 多线程锁使用：通常用于系统底层，同步多个 CPU 对共享资源的访问
- 锁的持有时间非常短：例如，对于某些非常简单的操作（如计数器的增减），自旋锁可以有效减少线程上下文切换的开销。
- 锁争用较少：如果多个线程竞争同一个锁的概率较小，则使用自旋锁可以减少等待时间，避免上下文切换的开销。
2.5 自旋锁 VS 互斥锁
🔥 与传统的互斥锁（Mutex）不同，互斥锁通常会让线程在无法获得锁时进入休眠状态，减少 CPU 的浪费，而自旋锁则在锁被占用时不断轮询，直到获取到锁。这种方式通常用于锁持有时间较短的场景，因为自旋锁避免了线程切换的开销，但是不合理的使用，可能也会浪费 CPU 资源
3. 共勉 🔥
【*★,°*:.☆(￣▽￣)/$:*.°★* 】那么本篇到此就结束啦，如果有不懂 和 发现问题的小伙伴可以在评论区说出来哦，同时我还会继续更新关于【Linux】的内容，请持续关注我 ！！
