Linux线程浅析[线程的同步和互斥之线程读写锁]

Linux线程浅析[线程的同步和互斥之线程读写锁]

读写锁的出现是为了解决互斥锁的弊端

使用上述Linux线程浅析[线程的同步和互斥之线程互斥锁]的案例来进行解释吧，即针对上述案例中的银行存取款的互斥锁，当一个账户去访问的时候，另外一个账户其实就需要被阻塞，但是现实中往往会有这样一种情况，一个人去存，但是其余的人是去查询，如果存的人获取了锁，那么查询的人就需要被阻塞，这就导致了查询效率极低的这样的一种情况

什么是读写锁：

　概念：

读写锁实际是一种特殊的自旋锁，它把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作。

　读写锁的使用场景：

　

线程互斥——读写锁

线程使用互斥锁缺乏读并发性

当读操作较多时，写操作较少时，可以使用读写锁来提高线程读并发性

读写锁：
pthread_rwlock_t

读写锁的相关函数：

#include<pthread.h>
int pthread_wrlock_init(pthread_rwlock_t *restrict rwlock,const     pthread_rwlockattr_t *restrict attr);
int ptrhead_wrlock_destory(pthread_rwlock_t *rwlock)
成功：返回0,出错返回错误编码
参数:
rwlock:读写锁
attr:读写锁属性

读写锁加锁和加写锁

#include<pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock)
功能:加读锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock)
功能：加写锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock)
功能：释放锁
返回：成功返回0,失败返回错误编码
参数：rwlock：读写锁

　如下表格所示：

类型	readlock	writelock
readlock	读锁和读锁不排斥	先写锁成功，读锁失败
writelock	先读锁成功，写锁阻塞	先写成功，后写失败

　表格总结(同一把读写锁)：

　１：如果一个函数上了读锁，两个线程一起调用的时候是不会发生排斥现象的(不排斥)

　２:如果一个函数上了读锁，另一个函数上了写锁，那么线程一先调用读锁函数，线程二再调用写锁函数的时候，这个时候线程二是会阻塞住的(排斥)

３:如果一个函数上了读锁，另外一个函数上了写锁，当线程一先调用写锁函数，线程二再调用读锁函数的时候，这个时候线程二是会加锁失败(排斥)

４:一个函数上了写锁，两个线程同时调用写锁函数．第一个调用成功，第二个会失败(排斥)

那么通过读写锁的形式对原来互斥锁的银行案例进行修改:

/*
* ===========================================================================
*
*       Filename:  account.h
*    Description:
*        Version:  1.0
*        Created:  2017年03月28日 22时04分18秒
*       Revision:  none
*       Compiler:  gcc
*         Author:   (),
*        Company:
*
* ===========================================================================
*/

#ifndef __ACCOUNT_H_
#define __ACCOUNT_H_
//声明银行账户的结构体
//引用ｐｔｈｒｅａｄ头文件．方便后面加锁
#include<pthread.h>
typedef struct{
int code;
double balance;
//将锁声明在结构体中，有助于每一个这样的结构体都有一把锁，那么在操作的时候，有利于优化并发效果
//pthread_mutex_t pthreadmutex;
pthread_rwlock_t pthreadrwlock;
}Account;

//创建银行账户
extern Account* create_account(int code,double balance);

//销毁一个账户
extern void destory_account(Account* account);

//存款
extern double withdraw(Account* account,double amt);

//取款
extern double deposit(Account* a,double amt);

//查看账户余额
extern double get_balance(Account* account);

#endif

/*
* ===========================================================================
*
*       Filename:  account.c
*    Description:
*        Version:  1.0
*        Created:  2017年03月30日 21时16分28秒
*       Revision:  none
*       Compiler:  gcc
*         Author:   (),
*        Company:
*
* ===========================================================================
*/

#include"account.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<assert.h>
#include<pthread.h>

//static pthread_mutexattr_t attr;
/*
*创建一个账户
*返回这个账户的指针
*
* */
extern Account* create_account(int code,double balance){
Account* account = (Account*)malloc(sizeof(Account));
assert(account !=NULL);
account->code = code;
account->balance = balance;
//初始化锁的过程
//pthread_mutexattr_init(&attr);
//pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_NORMAL);
//pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
//pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK);
//pthread_mutex_init(&account->pthreadmutex,NULL);
//pthread_mutex_init(&account->pthreadmutex,&attr);

//初始化读写锁
pthread_rwlock_init(&account->pthreadrwlock,NULL);

return account;
}
/* *
*销毁一个账户
* */
extern void destory_account(Account* account){
assert(account!=NULL);
free(account);
//销毁锁的过程
//pthread_mutexattr_destroy(&attr);
//pthread_mutex_destroy(&account->pthreadmutex);
//
//销毁读写锁
pthread_rwlock_destroy(&account->pthreadrwlock);
}

/* *
*取款，返回的是账户的余额
*
* */
extern double withdraw(Account * account,double amt){
assert(account != NULL);
//上锁的过程
//pthread_mutex_lock(&account->pthreadmutex);
//上读写锁(读锁)

pthread_rwlock_wrlock(&account->pthreadrwlock);

if(amt < 0 || amt > account->balance){
//解锁的过程
//pthread_mutex_unlock(&account->pthreadmutex);
//
//解读写锁
pthread_rwlock_unlock(&account->pthreadrwlock);
return 0.0;
}
int balance = account -> balance;
sleep(1);
int result = balance - amt;
account ->balance = result;
//解锁的过程
//pthread_mutex_unlock(&account->pthreadmutex);
//
//解读写锁
pthread_rwlock_unlock(&account->pthreadrwlock);
return amt;
}
/* *
*存款，返回的也是账户的余额
*
* */
extern double deposit(Account* account,double amt){
assert(account != NULL);
//上锁的过程
//pthread_mutex_lock(&account->pthreadmutex);
//上读写锁(读锁)
pthread_rwlock_wrlock(&account->pthreadrwlock);
if(amt < 0){
//解锁的过程
//pthread_mutex_unlock(&account->pthreadmutex);
//解读写锁
pthread_rwlock_unlock(&account->pthreadrwlock);
return 0.0;
}
int balance = account ->balance;
sleep(2);
int result = balance + amt;
account->balance = result;
//解锁的过程
//pthread_mutex_unlock(&account->pthreadmutex);
//解读写锁
pthread_rwlock_unlock(&account->pthreadrwlock);
return result;
}

/* *
*获取的就是这个账户的余额
*
* */
extern double get_balance(Account* account){
assert(account !=NULL);
//上读写锁(读锁)
pthread_rwlock_rdlock(&account->pthreadrwlock);
int result = account->balance;
//解决读写锁
pthread_rwlock_unlock(&account->pthreadrwlock);
return result;
}

其他部分的执行代码在互斥锁中有，所以在这里就不去赘述了．

欢迎持续访问博客