自学内容网 自学内容网
自学内容网 > 正文

【Linux】读者写者问题与读写锁

🕗 发布于 2024-11-14 16:41 开发语言  

目录

读写锁

读写锁是什么

如何理解读者写者问题

读写锁案例

读者优先

写者优先

自旋锁

原理

自旋锁原理实现

优缺点

读写锁

读写锁是什么

比如写博客，我们去写，别人来读。再比如别人写出来书籍，我们去读。在计算机中，由线程去承担读者写者这样的角色。和之前学过的生产消费模型一样，也应该遵循“321”原则，

3：3种关系，包括读者和读者、读者和写者、写者和写者

2：2种角色

1：1个交易场所

写者和写者之间要维护互斥关系，读者和写者之间要维护同步&&互斥关系，最主要的是读者和读者之间是并发关系（没关系）。那为什么读者和读者之间没有关系呢？我们来对比一下读者写者与生产消费，消费者会把数据取走！！而读者不会！！

如何理解读者写者问题

下面是一段伪代码，

uint32_t reader_count = 0;
lock_t count_lock;
lock_t writer_lock;

Reader

// 加锁
lock(count_lock); //统计当前有多少个读者在读
if(reader_count == 0)
lock(writer_lock);
++reader_count;
unlock(count_lock);
// read;
//解锁
lock(count_lock);
--reader_count;
if(reader_count == 0)
unlock(writer_lock);
unlock(count_lock);

在读者访问临界资源前，读者先加上计数器的锁，然后再解计数器锁，之间判断如果读者数为0，那这是第一个读者，那就把写者要用到的锁申请到，此时即便写者要写入，因为写锁已经被拿走，写者就进不来了。然后读者对临界资源进行读取，所有线程陆续同时访问临界资源。当读者数为0，那就释放写锁，写者就可以申请到写锁，进行写入。如果写者先来，那就读者就需要等待写者。

Writer

lock(writer_lock);
// write
unlock(writer_lock);

一般而言，读者写者模型应用于读者很多，写者很少的情况。

实际上，在pthread库中，提供了读写锁，

初始化和销毁

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

加锁和解锁

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);//以读者身份加锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);//以写者身份加锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

读写锁案例

#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)
{
    //sleep(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;
}

读者优先

在这种策略中，系统会尽可能多地允许多个读者同时访问资源（比如共享文件或数据），而不会优先考虑写者。这意味着当有读者正在读取时，新到达的读者会立即被允许进入读取区，而写者则会被阻塞，直到所有读者都离开读取区。读者优先策略可能会导致写者饥饿（即写者长时间无法获得写入权限），特别是当读者频繁到达时。

写者优先

在这种策略中，系统会优先考虑写者。当写者请求写入权限时，系统会尽快地让写者进入写入区， 即使此时有读者正在读取。这通常意味着一旦有写者到达，所有后续的读者都会被阻塞，直到写者完成写入并离开写入区。写者优先策略可以减少写者等待的时间，但可能会导致读者饥饿（即读者长时间无法获得读取权限），特别是当写者频繁到达时。

自旋锁

自旋锁是一种多线程同步机制，用于保护共享资源免受并发访问的影响。在多个线程尝试获取锁时，它们会持续自旋（即在一个循环中不断检查锁是否可用，在轮询检测）而不是立即进入休眠状态等待锁的释放。这种机制减少了线程切换的开销，适用于短时间内锁的竞争情况。但是不合理的使用，可能会造成 CPU 的浪费。这就比如我们在等人的时候，等人的时长决定了我们等待的方式！！

假设线程A进入了临界区，但是在临界区里面待的时间非常短，此时线程B、C、D...都来申请锁了，申请锁失败了就必须等别的线程把锁释放，线程B、C、D...可以选择把自己阻塞等待，也就是把线程的tcb从R状态设为S状态，然后把线程控制块列入到等待队列里。把线程唤醒就是把S状态设为R状态，然后把线程tcb添加到运行队列里。但是由运行队列添加到等待队列和由等待队列添加到运行队列的过程是需要花费时间的。如果线程A在临界区待的时间比较长，那么让线程阻塞等待是划算的，但如果线程A在临界资源里待的时间非常短，那阻塞等待就是不划算的，所以，其他线程可以不阻塞等待，而是循环式地不断检测锁释放了没有，由于线程A在临界区的时间很短，那其他线程很快就能申请到锁，这种不断去申请锁而不会让线程阻塞等待称为自旋锁。

原理

自旋锁通常使用一个共享的标志位（如一个布尔值）来表示锁的状态。当标志位为true 时，表示锁已被某个线程占用；当标志位为 false 时，表示锁可用。当一个线程尝试获取自旋锁时，它会不断检查标志位：

  • 如果标志位为 false，表示锁可用，线程将设置标志位为 true，表示自己占用了锁，并进入了临界区。
  • 如果标志位为true（即锁已被其他线程占用），线程会在一个循环中不断自旋等待，直到锁被释放。

自旋锁原理实现

自旋锁的实现通常使用原子操作来保证操作的原子性，以下是一个简单的自旋锁实现示例：

C++
#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);
}
C++
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的读取和修改是不可分割的。当一个线程调用此函数时，其他线程无法看到这个操作的任何中间状态，这确保了操作的线程安全性。

以上是我们自己模拟的自旋锁，但实际上pthread库已经为我们封装好了，

#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);

优缺点

优点

1.低延迟：自旋锁适用于短时间内的锁竞争情况，因为它不会让线程进入休眠状态，从而避免了线程切换的开销，提高了锁操作的效率。

2.减少系统调度开销：等待锁的线程不会被阻塞，不需要上下文切换，从而减少了系统调度的开销。

缺点

1.CPU 资源浪费：如果锁的持有时间较长，等待获取锁的线程会一直循环等待，导致 CPU 资源的浪费。

2.可能引起活锁：当多个线程同时自旋等待同一个锁时，如果没有适当的退避策略，可能会导致所有线程都在不断检查锁状态而无法进入临界区，形成活锁。


原文地址：https://blog.csdn.net/qq_48460693/article/details/143679516

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024