Linux中读写锁详细介绍

读写锁介绍

Linux 中的读写锁（Read-Write Lock）是一种用于线程同步的机制，它允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。这种机制在读操作远多于写操作的场景下，可以显著提高并发性能。读写锁主要有以下特点：

读写锁区分了对共享资源的读取和写入操作。这使得它可以根据不同的操作类型，采用不同的锁定策略。

对于读锁（共享）来说，允许多个线程同时持有，用于保护读取操作，当有线程持有读锁时，其他线程也可以获取读锁。

对于写锁（独占）来说，一次只能有一个线程持有，用于保护写入操作，当有线程持有写锁时，其他线程都不能获取读锁或者写锁。

想要获取读锁和写锁的要求：

        一个线程想要成功获取某资源的读锁，要求其他线程不持有任何锁或者只持有读锁可以获取成功，如果其他线程持有该资源写锁的话就获取不成功。

        一个线程想要成功获取某资源的写锁，要求其他线程不持有任何锁才可以获取成功，如果其他线程持有该资源写锁或者该资源读锁的话就获取不成功。

读写锁的适用情况

读写锁的优点：

• 提高读操作并发性：在读多写少的场景下，读写锁可以显著提高读取操作的并发性，从而提高程序的整体性能。
• 减少线程阻塞：与互斥锁相比，读写锁减少了线程因读取操作而阻塞的概率，这提高了线程的利用率和程序的响应速度。

读写锁的适用情况：

• 读多写少的共享资源：
  • 例如，配置文件、数据缓存、查找表等。
• 需要频繁读取但很少修改的数据：
  • 例如，传感器数据、实时监控数据等。

互斥锁VS读写锁

互斥锁确保了在任何时刻只有一个线程可以访问受保护的资源，无论是读取还是写入。

读写锁的适合使用在在读操作远多于写操作的场景下，它允许多个线程同时读取共享资源，提高了读操作的并发性，但只允许一个线程写入，对于资源写操作没有提高。

读写锁的使用流程

1. 初始化读写锁： 使用pthread_rwlock_init()创建读写锁。
2. 获取锁：

   读取共享资源前，使用pthread_rwlock_rdlock()获取读锁。

   写入共享资源前，使用pthread_rwlock_wrlock()获取写锁。

3. 访问共享资源： 在读写锁的保护下，安全地访问共享资源。
4. 解锁读写锁： 在完成共享资源访问后，使用pthread_rwlock_unlock()解锁读写锁。
5. 销毁读写锁： 在读写锁不再使用时，使用pthread_rwlock_destroy()销毁它。

pthread_rwlock_init()：初始化读写锁

函数作用：初始化一个读写锁。

函数原型：int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);

参数：

• rwlock：指向要初始化的读写锁变量的指针。
• attr：读写锁属性，通常设置为NULL表示使用默认属性。

返回值：

成功返回0，失败返回错误码。

注意：

• 为了让多个线程都能使用同一个读写锁，读写锁变量必须定义于线程可以共享访问的内存区域，比如全局变量静态变量或者堆上，读写锁变量的类型为pthread_rwlock_t。
• 使用读写锁的第一步必须是初始化读写锁，不初始化可能会出现未定义情况。
• 通常来说pthread_rwlock_init函数的第二个参数attr我们会设置为NULL，此时会创建一个默认属性的读写锁，完全已经够用。

pthread_rwlock_rdlock()：获取读锁

函数作用：获取读锁。

函数原型：int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

参数：

rwlock：指向要获取读锁的读写锁变量的指针。

返回值：

成功返回0，失败返回错误码。

注意：

• 如果当前没有线程持有写锁，调用线程将立即获得读锁。
• 如果当前有线程持有写锁，调用线程将被阻塞，直到写锁被释放。

pthread_rwlock_tryrdlock()：尝试获取读锁

函数作用：尝试获取读锁，如果读写锁已被写锁定，则不阻塞，立即返回错误。

函数原型：int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

参数：

rwlock：指向要尝试获取读锁的读写锁变量的指针。

返回值：

• 成功锁定返回0。
• 如果读写锁已被写锁定，返回EBUSY。
• 其他错误返回相应的错误码。

注意：

• pthread_rwlock_tryrdlock()是非阻塞的，它不会使调用线程进入等待状态。
• 这个函数在需要非阻塞的锁定操作时很有用。

pthread_rwlock_wrlock()：获取写锁

函数作用：获取写锁。

函数原型：int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

参数：

rwlock：指向要获取写锁的读写锁变量的指针。

返回值：

成功返回0，失败返回错误码。

注意：

• 如果当前没有线程持有读锁或写锁，调用线程将立即获得写锁。
• 如果当前有线程持有读锁或写锁，调用线程将被阻塞，直到所有锁都被释放。

pthread_rwlock_trywrlock()：尝试获取写锁

函数作用：尝试获取写锁，如果读写锁已被读锁定或写锁定，则不阻塞，立即返回错误。

函数原型：int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

参数：

rwlock：指向要尝试获取写锁的读写锁变量的指针。

返回值：

• 成功锁定返回0。
• 如果读写锁已被读锁定或写锁定，返回EBUSY。
• 其他错误返回相应的错误码。

注意：

• pthread_rwlock_trywrlock()是非阻塞的，它不会使调用线程进入等待状态。
• 这个函数在需要非阻塞的锁定操作时很有用。

pthread_rwlock_unlock()：解锁读写锁

函数作用：解锁读写锁

函数原型：int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);

参数：

rwlock：指向要解锁的读写锁变量的指针。

返回值：

成功返回0，失败返回错误码。

注意：

• 解锁读写锁后，其他等待该读写锁的线程可以获得锁。
• 持有读锁或写锁的线程都可以使用这个函数解锁。

一个线程对于同一个读写锁，在同一时间点上，只能拥有读锁或者写锁，不能同时拥有。

所以使用pthread_rwlock_unlock()进行解锁时，不需要指定解的是读锁还是写锁。操作系统内部会维护读写锁的状态，并且根据内部状态来确定如何解锁，这样设计简化了读写锁的使用

pthread_rwlock_destroy()：销毁读写锁

函数作用：销毁一个读写锁。

函数原型：int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

参数：

rwlock：指向要销毁的读写锁变量的指针。

返回值：

成功返回0，失败返回错误码。

注意：

• 在读写锁不再使用时，应该及时销毁它以释放资源。
• 只有未被任何线程锁定的读写锁才能被销毁。

读写锁使用示例

示例：共享数据缓存

假设我们有一个共享的数据缓存，多个线程需要读取缓存中的数据，而只有少数线程需要更新缓存。

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

#define NUM_READERS 5
#define NUM_WRITERS 2

// 共享数据缓存
int data_cache = 0;
// 读写锁
pthread_rwlock_t rwlock;

// 读线程函数
void *reader_thread(void *arg) {
    int thread_id = *(int *)arg;

    // 获取读锁
    pthread_rwlock_rdlock(&rwlock);

    // 读取共享数据
    printf("Reader %d: Reading data_cache = %d\n", thread_id, data_cache);
    sleep(1); // 模拟耗时读取操作

    // 释放读锁
    pthread_rwlock_unlock(&rwlock);

    pthread_exit(NULL);
}

// 写线程函数
void *writer_thread(void *arg) {
    int thread_id = *(int *)arg;

    // 获取写锁
    pthread_rwlock_wrlock(&rwlock);

    // 更新共享数据
    data_cache++;
    printf("Writer %d: Updated data_cache = %d\n", thread_id, data_cache);
    sleep(2); // 模拟耗时写入操作

    // 释放写锁
    pthread_rwlock_unlock(&rwlock);

    pthread_exit(NULL);
}

int main() {
    pthread_t readers[NUM_READERS];
    pthread_t writers[NUM_WRITERS];
    int reader_ids[NUM_READERS];
    int writer_ids[NUM_WRITERS];

    // 初始化读写锁
    if (pthread_rwlock_init(&rwlock, NULL) != 0) {
        perror("pthread_rwlock_init");
        exit(EXIT_FAILURE);
    }

    // 创建读线程
    for (int i = 0; i < NUM_READERS; i++) {
        reader_ids[i] = i;
        if (pthread_create(&readers[i], NULL, reader_thread, &reader_ids[i]) != 0) {
            perror("pthread_create (reader)");
            exit(EXIT_FAILURE);
        }
    }

    // 创建写线程
    for (int i = 0; i < NUM_WRITERS; i++) {
        writer_ids[i] = i;
        if (pthread_create(&writers[i], NULL, writer_thread, &writer_ids[i]) != 0) {
            perror("pthread_create (writer)");
            exit(EXIT_FAILURE);
        }
    }

    // 等待读线程结束
    for (int i = 0; i < NUM_READERS; i++) {
        pthread_join(readers[i], NULL);
    }

    // 等待写线程结束
    for (int i = 0; i < NUM_WRITERS; i++) {
        pthread_join(writers[i], NULL);
    }

    // 销毁读写锁
    if (pthread_rwlock_destroy(&rwlock) != 0) {
        perror("pthread_rwlock_destroy");
        exit(EXIT_FAILURE);
    }

    return 0;
}

代码解释：

1. 包含头文件：
   • stdio.h：用于输入输出。
   • stdlib.h：用于标准库函数。
   • pthread.h：用于线程相关函数。
   • unistd.h：用于sleep()函数。
2. 定义共享数据和读写锁：
   • data_cache：一个整数变量，作为共享数据缓存。
   • rwlock：一个pthread_rwlock_t类型的变量，用于读写锁。
3. 读线程函数reader_thread()：
   • 每个读线程执行这个函数。
   • 首先，使用pthread_rwlock_rdlock()获取读锁。
   • 然后，读取共享数据data_cache。
   • 使用sleep()模拟耗时读取操作。
   • 最后，使用pthread_rwlock_unlock()释放读锁。
4. 写线程函数writer_thread()：
   • 每个写线程执行这个函数。
   • 首先，使用pthread_rwlock_wrlock()获取写锁。
   • 然后，更新共享数据data_cache。
   • 使用sleep()模拟耗时写入操作。
   • 最后，使用pthread_rwlock_unlock()释放写锁。
5. main()函数：
   • 初始化读写锁：使用pthread_rwlock_init()初始化读写锁。
   • 创建读线程：创建多个读线程，并传递线程ID作为参数。
   • 创建写线程：创建多个写线程，并传递线程ID作为参数。
   • 等待线程结束：使用pthread_join()等待所有线程结束。
   • 销毁读写锁：使用pthread_rwlock_destroy()销毁读写锁。

程序输出显示读线程并发读取共享数据的过程，以及写线程更新共享数据的过程。由于读写锁的保护，读线程可以并发执行，而写线程的更新操作是互斥的。