【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 <pthread.h>
#include <stdio.h>

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 <pthread.h>
#include <stdio.h>

pthread_rwlock_t rwlock;

void* read_data(void* arg) {
    pthread_rwlock_rdlock(&rwlock);  // 获取读锁
    printf("Reading data...\n");
    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 <pthread.h>
#include <stdio.h>

pthread_rwlock_t rwlock;

void* write_data(void* arg) {
    pthread_rwlock_wrlock(&rwlock);  // 获取写锁
    printf("Writing data...\n");
    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 <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <cstdlib>
#include <ctime>

// 共享资源
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 <stdio.h>
#include <stdatomic.h>
#include <pthread.h>
#include <unistd.h>
// 使用原子标志来模拟自旋锁
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 <pthread.h>

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 <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>

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\n", 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 <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>

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\n", 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 循环内部，因为需要一直自检锁，此时结果如下：