线程 -- 读写锁

读写锁

与互斥量类似,但读写锁允许更高的并行性。其特性为:写独占,读共享。

读写锁的状态

写锁具备三种状态：

1. 读模式下加锁状态(读锁).
2. 写模式下加锁状态(写锁).
3. 不加锁状态.

读写锁的特性

读锁可以重复加，当加读锁，线程可以同时读取文件。此时加写锁，会被阻塞，直到读锁全部解锁。

写锁只能加一次，只有加锁的进程可以修改文件。此时加读锁写锁都会被阻塞，直到写锁解锁。

写锁的优先级高于读锁。

读写线程场景分析

• 线程A有写锁，线程B请求读锁 答：B阻塞
• 线程A有写锁，线程B请求写锁 答：B阻塞
• 线程A有读锁，线程B请求写锁 答：B阻塞
• 线程A有读锁，线程B请求读锁 答：B加锁成功
• 线程A持有读锁，线程B先请求写锁，线程C再请求读锁 答：BC都阻塞 A释放后B加锁，B释放后C加锁
• 线程A持有读锁，线程B先请求读锁，线程C再请求写锁 答：线程B加锁成功，线程C阻塞
• 线程A持有写锁，线程B先请求读锁，线程C再请求写锁 答：BC阻塞，A释放后C加锁，C释放后B加锁

读写锁适用场景

适合读的线程多的时候。

读写锁使用函数

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

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

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

**例子 : **

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

int num = 1000;
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;


// 线程1
void *thr_read(void *arg)
{
    while(1)
    {
        pthread_rwlock_rdlock(&rwlock);
        printf("B我是读线程%lu 开始我读的是：%d\n",pthread_self(),num);
        sleep(rand()%3);
        printf("N我是读线程%lu 最后我读的是：%d\n",pthread_self(),num);
        pthread_rwlock_unlock(&rwlock);
        sleep(2);
    }
    pthread_exit(NULL);
}

// 线程2
void *thr_write(void *arg)
{
    while(1)
    {
        pthread_rwlock_wrlock(&rwlock);
        printf("我是写线程%lu 开始的数据是：%d\n",pthread_self(),num);
        num += 100;
        sleep(rand()%3);
        printf("我是写线程%lu 最后的数据是：%d\n\n",pthread_self(),num);
        pthread_rwlock_unlock(&rwlock);
        sleep(2);
    }
    pthread_exit(NULL);
}

main()
{
    int n = 8,i = 0;;
    // 创建进程
    pthread_t tid[n];
    for(i; i<5;i++)
    {
        pthread_create(&tid[i],NULL,thr_read,NULL);
    }
    for(i; i<n; i++)
    {
        pthread_create(&tid[i],NULL,thr_write,NULL);
    }

    // 回收进程
    for(i=0; i<n; i++)
    {
        pthread_join(tid[i], NULL);
    }
}

**运行结果 ： **

[dai@localhost 06线程-2]$ ./04读写锁
我是写线程139836323407616 开始的数据是：1000
我是写线程139836323407616 最后的数据是：1100

我是写线程139836315014912 开始的数据是：1100
我是写线程139836315014912 最后的数据是：1200

我是写线程139836306622208 开始的数据是：1200
我是写线程139836306622208 最后的数据是：1300

B我是读线程139836356978432 开始我读的是：1300
B我是读线程139836348585728 开始我读的是：1300
B我是读线程139836340193024 开始我读的是：1300
B我是读线程139836331800320 开始我读的是：1300
B我是读线程139836365371136 开始我读的是：1300
N我是读线程139836365371136 最后我读的是：1300
N我是读线程139836356978432 最后我读的是：1300
N我是读线程139836340193024 最后我读的是：1300
N我是读线程139836331800320 最后我读的是：1300
N我是读线程139836348585728 最后我读的是：1300
B我是读线程139836365371136 开始我读的是：1300
N我是读线程139836365371136 最后我读的是：1300
我是写线程139836323407616 开始的数据是：1300
我是写线程139836323407616 最后的数据是：1400

我是写线程139836306622208 开始的数据是：1400
^Z
[2]+ 已停止 ./04读写锁