线程 -- 读写锁

读写锁

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

读写锁的状态

写锁具备三种状态:

  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读写锁

上一篇:Go语言并发通信


下一篇:线程同步 - mutex建议锁