使用互斥锁和条件变量实现读写锁

最新推荐文章于 2024-06-27 01:38:03 发布
最新推荐文章于 2024-06-27 01:38:03 发布
阅读量736 收藏 2
点赞数
分类专栏： unp2 文章标签： UNPv2 互斥锁 条件变量 读写锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TT_love9527/article/details/81987215
版权

只使用互斥锁和条件变量实现读写锁，此读写锁的实现优先考虑等待着的写入者。

1、pthread_rwlock_t数据类型

给出一个pthread_rwlock.h头文件，其中pthread_rwlock_t数据结构由一个互斥锁、一个读条件变量、一个写条件变量、一个标志位及三个计数量（读条件变量等候计数器、写条件变量等候计数器、读写锁引用计数器）构成。

/* include rwlockh */
#ifndef	__pthread_rwlock_h
#define	__pthread_rwlock_h

typedef struct {
  pthread_mutex_t	rw_mutex;		/* basic lock on this struct */ //互斥锁
  pthread_cond_t	rw_condreaders;	/* for reader threads waiting *///服务于读的条件变量
  pthread_cond_t	rw_condwriters;	/* for writer threads waiting *///服务于写的条件变量
  int				rw_magic;		/* for error checking *///读写锁初始化成功后，即被设置成RW_MAGIC，用来检测所传递的指针所指读写锁是否被初始化
  int				rw_nwaitreaders;/* the number waiting *///记录等待读出锁使用的数量
  int				rw_nwaitwriters;/* the number waiting *///记录等待写入锁使用的数量
  int				rw_refcount;//此值为-1表明写入锁正使用，为0，表明没有人使用读写锁，>1，表明有人使用读出锁
	/* 4-1 if writer has the lock, else # readers holding the lock */
} pthread_rwlock_t;

#define	RW_MAGIC	0x19283746

	/* 4following must have same order as elements in struct above */
#define	PTHREAD_RWLOCK_INITIALIZER	{ PTHREAD_MUTEX_INITIALIZER, \
			PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER, \
			RW_MAGIC, 0, 0, 0 }

typedef	int		pthread_rwlockattr_t;	/* dummy; not supported */

	/* 4function prototypes */
int		pthread_rwlock_destroy(pthread_rwlock_t *);
int		pthread_rwlock_init(pthread_rwlock_t *, pthread_rwlockattr_t *);
int		pthread_rwlock_rdlock(pthread_rwlock_t *);
int		pthread_rwlock_tryrdlock(pthread_rwlock_t *);
int		pthread_rwlock_trywrlock(pthread_rwlock_t *);
int		pthread_rwlock_unlock(pthread_rwlock_t *);
int		pthread_rwlock_wrlock(pthread_rwlock_t *);


#endif	__pthread_rwlock_h
/* end rwlockh */

2、pthread_rwlock_init函数

pthread_rwlock_init动态初始化一个读写锁。

/* include init */
#include	"unpipc.h"
#include	"pthread_rwlock.h"

int
pthread_rwlock_init(pthread_rwlock_t *rw, pthread_rwlockattr_t *attr)
{
	int		result;

	if (attr != NULL)
		return(EINVAL);		/* not supported */

	if ( (result = pthread_mutex_init(&rw->rw_mutex, NULL)) != 0)//最后一个NULL，表示不给rwlock互斥锁赋属性，下同
		goto err1;
	if ( (result = pthread_cond_init(&rw->rw_condreaders, NULL)) != 0)
		goto err2;
	if ( (result = pthread_cond_init(&rw->rw_condwriters, NULL)) != 0)
		goto err3;
	rw->rw_nwaitreaders = 0;
	rw->rw_nwaitwriters = 0;
	rw->rw_refcount = 0;
	rw->rw_magic = RW_MAGIC;

	return(0);

err3:
	pthread_cond_destroy(&rw->rw_condreaders);
err2:
	pthread_mutex_destroy(&rw->rw_mutex);
err1:
	return(result);			/* an errno value */
}
/* end init */

3、pthread_rwlock_destroy函数

/* include destroy */
#include	"unpipc.h"
#include	"pthread_rwlock.h"

int
pthread_rwlock_destroy(pthread_rwlock_t *rw)
{
	if (rw->rw_magic != RW_MAGIC)//通过此标志位检测是否已初始化该读写锁
		return(EINVAL);
	if (rw->rw_refcount != 0 ||//此条件语句检测读写是否不在使用中
		rw->rw_nwaitreaders != 0 || rw->rw_nwaitwriters != 0)
		return(EBUSY);

	pthread_mutex_destroy(&rw->rw_mutex);
	pthread_cond_destroy(&rw->rw_condreaders);
	pthread_cond_destroy(&rw->rw_condwriters);
	rw->rw_magic = 0;//此标志位置0，表明此读写锁不再使用

	return(0);
}
/* end destroy */

4、pthread_rwlock_rdlock函数

/* include rdlock */
#include	"unpipc.h"
#include	"pthread_rwlock.h"

int
pthread_rwlock_rdlock(pthread_rwlock_t *rw)
{
	int		result;

	if (rw->rw_magic != RW_MAGIC)
		return(EINVAL);

	if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)//操作读写锁之前，先上互斥锁
		return(result);

		/* 4give preference to waiting writers */
	while (rw->rw_refcount < 0 || rw->rw_nwaitwriters > 0) {//正在有写入锁或有等待需要调用写入锁时，条件为真
		rw->rw_nwaitreaders++;//给需要调用读取锁者数量+1
		result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex);//进入睡眠，释放互斥锁，等待读条件变量信号刺激
		rw->rw_nwaitreaders--;//一旦被读条件变量信号刺激，说明可以进行加读出锁，给需要调用读取锁者数量-1
		if (result != 0)
			break;
	}
	if (result == 0)
		rw->rw_refcount++;		/* another reader has a read lock */

	pthread_mutex_unlock(&rw->rw_mutex);//加读取锁完成，释放互斥锁
	return (result);
}
/* end rdlock */

稍后将看到，当给一个读写锁解锁时，首先检查是否有任何等待着的写入者（体现了优先考虑写入者原则），若没有则检查是否有任何等待着的读出者。如果有读出者在等待，则向rw_condreaders条件变量广播信号。

5、pthread_rwlock_tryrdlock函数（无法上读取锁，即返回EBUSY错误，实现比较简单）

/* include tryrdlock */
#include	"unpipc.h"
#include	"pthread_rwlock.h"

int
pthread_rwlock_tryrdlock(pthread_rwlock_t *rw)
{
	int		result;

	if (rw->rw_magic != RW_MAGIC)
		return(EINVAL);

	if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
		return(result);

	if (rw->rw_refcount < 0 || rw->rw_nwaitwriters > 0)
		result = EBUSY;			/* held by a writer or waiting writers */
	else
		rw->rw_refcount++;		/* increment count of reader locks */

	pthread_mutex_unlock(&rw->rw_mutex);
	return(result);
}
/* end tryrdlock */

6、pthread_rwlock_wrlock函数

/* include wrlock */
#include	"unpipc.h"
#include	"pthread_rwlock.h"

int
pthread_rwlock_wrlock(pthread_rwlock_t *rw)
{
	int		result;

	if (rw->rw_magic != RW_MAGIC)
		return(EINVAL);

	if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)//加互斥锁
		return(result);

	while (rw->rw_refcount != 0) {//条件为真，表明有调用者持有写入锁或读出锁，这时不能直接上写入锁
		rw->rw_nwaitwriters++;//调用写入锁者的数量+1
		result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex);//投入睡眠，释放互斥锁，等待着写条件变量信号刺激
		rw->rw_nwaitwriters--;//一旦被写条件变量信号刺激，说明可以进行加写入锁，给需要调用写入锁者数量-1
		if (result != 0)
			break;
	}
	if (result == 0)
		rw->rw_refcount = -1;

	pthread_mutex_unlock(&rw->rw_mutex);//释放互斥锁
	return(result);
}
/* end wrlock */

稍后将看到，向写条件变量发信号的前提是：它所在的读写锁被释放，并且有写入者正在等待。

7、pthread_rwlock_trywrlock函数（无法上写入锁，即返回EBUSY错误，实现比较简单）

/* include trywrlock */
#include	"unpipc.h"
#include	"pthread_rwlock.h"

int
pthread_rwlock_trywrlock(pthread_rwlock_t *rw)
{
	int		result;

	if (rw->rw_magic != RW_MAGIC)
		return(EINVAL);

	if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
		return(result);

	if (rw->rw_refcount != 0)
		result = EBUSY;			/* held by either writer or reader(s) */
	else
		rw->rw_refcount = -1;	/* available, indicate a writer has it */

	pthread_mutex_unlock(&rw->rw_mutex);
	return(result);
}
/* end trywrlock */

8、pthread_rwlock_unlock函数

/* include unlock */
#include	"unpipc.h"
#include	"pthread_rwlock.h"

int
pthread_rwlock_unlock(pthread_rwlock_t *rw)
{
	int		result;

	if (rw->rw_magic != RW_MAGIC)
		return(EINVAL);

	if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
		return(result);

	if (rw->rw_refcount > 0)
		rw->rw_refcount--;			/* releasing a reader */
	else if (rw->rw_refcount == -1)
		rw->rw_refcount = 0;		/* releasing a reader */
	else
		err_dump("rw_refcount = %d", rw->rw_refcount);

		/* 4give preference to waiting writers over waiting readers */
	if (rw->rw_nwaitwriters > 0) {//优先考虑获取写入锁的等待者
		if (rw->rw_refcount == 0)//表明读写锁被释放，且有需要等待获取写入锁的调用者时，给予写条件变量信号刺激
			result = pthread_cond_signal(&rw->rw_condwriters);
	} else if (rw->rw_nwaitreaders > 0)//当有需要读出锁时
		result = pthread_cond_broadcast(&rw->rw_condreaders);//广播读条件变量信号

	pthread_mutex_unlock(&rw->rw_mutex);
	return(result);
}
/* end unlock */

以上知识点来均来自steven先生所著UNP卷二（version2），刚开始学习网络编程，如有不正确之处请大家多多指正。

TT_love9527
关注
专栏目录
使用互斥锁实现读写锁
qq_41983709的博客
11-21 1637
下面是我的实现方式，如果不对。请大家指正！ 首先，我百度了一个测试用例： class Test { private : rw_lock rw; pthread_rwlock_t rwlock; static void* shared_task_handler(void* arg) { Test* testptr = static_ca...
c++使用条件变量与互斥锁来实现读写锁
weixin_44545838的博客
06-09 1072
读写锁与普通的互斥锁不同，它允许多个线程同时持有读锁，并且读取操作不会产生数据竞争，因此多个读取操作可以并发执行，提高了程序的并发性。而在写入操作时，为了保证数据的一致性，只能有一个线程持有写锁，其他的线程需要等待写锁被释放之后再进行操作。在 C++ 中，可以使用标准库中的 std::shared_mutex 类型来实现读写锁。std::shared_mutex 类型提供了 lock_shared、unlock_shared、lock 和 unlock 等方法，可以方便地实现读写锁。
互斥锁和条件变量实现读写锁
Sanjiye的博客
11-08 838
main函数test.c#include<stdio.h> #include<unistd.h> #include<pthread.h>#include"rwlock.h"my_pthread_rwlock_t rwlock = MY_PTHREAD_RWLOCK_INITIALIZER;#define N 5void* thread_fun(void *arg) { my_pthr
java干货 浅拷贝和深拷贝
最新发布
qq_51305563的博客
06-27 2951
java干货 浅拷贝和深拷贝
用互斥锁实现读写锁
m0_59674848的博客
08-01 594
为了实现多个线程并发的进行读操作，我们需要在读操作之前加锁，并在读操作完成后解锁。读计数器用于跟踪当前正在进行读操作的线程数量。在每个读操作的开头，需要先加锁读计数器，并将读计数器+1，表示当前有一个读操作正在进行。在读操作结束时，需要解锁读计数器，并将读计数器-1，表示当前的读操作已经完成。而对于读操作，多个线程可以并发的获取互斥锁，以允许多个读操作同时进行。需要特别注意的是，在上述实现中，读计数器的加锁和解锁过程需要在加锁和解锁共享数据之前和之后完成，以保证读计数器的正确更新和共享数据的正确访问。
用互斥锁和条件变量实现读写锁(读优先)
Y0uX1Nr3N的博客
04-11 505
不久前发过一个版本，是写优先的，当时觉得读优先跟写优先差不多就没写读优先后来想了想，还是有必要写一写的，好处是可以更为清晰的区分读优先和写优先之间实现的细小区别更能加深印象吧。依旧头文件部分，my_pthread_rwlock.h，顺便纠正上篇中的一个错误pthread_rwlock.h——应为my_pthread_rwlock.h#pragma once #include&lt;pth...
读写锁————用互斥量和条件变量模拟
weixin_33878457的博客
04-24 157
一. 读写锁 在多线程环境下为了防止对临界资源访问的冲突我们往往会在线程函数中加入互斥锁来完成线程间的互斥；但是，在有些情况下，互斥锁mutex并不是那么高效，比如当要对一块缓冲区进行读写操作的时候，因为读的需要比写入修改的需要要多，读取数据并不会修改缓冲区的数据个数或者内容，如果要使用互斥锁就会耗费额外的时间，每一次读取都要争夺锁资源挂起等待，因此就可以使用另外一种锁...
linux无亲缘关系间进程同步通信实现（互斥锁+条件变量+共享内存模式）
07-07
本主题将深入探讨如何使用互斥锁、条件变量以及共享内存这三种机制来实现无亲缘关系间进程的同步通信。 1. **互斥锁（Mutex）**： 互斥锁是一种基本的同步原语，用于保护共享资源。当一个进程获取了互斥锁后，其他...
线程同步（互斥锁、条件变量、读写锁、自旋锁）
weixin_49199646的博客
12-22 575
线程同步 所谓线程同步，就是有多个线程共享相同的内存时，需要确保共享数据在每个线程中都是一致的。若同一个共享变量在两个及以上线程中所显示的结果是不一样的，就表明线程不同步。 什么情况下需要使用线程同步？ 当一个线程可以修改的变量，其它线程也可以读取或修改的时候，必须进行线程同步，否则可能导致错误。 假设有两个线程A和B，需要对整型全局变量i进行递增操作，过程如下所示： 递增操作不是原子操作，编译器完成递增操作实际上需要3条机器指令： （1）将变量从内存单元读入寄存器； （2）在寄存器中对变量进行增量操作；
浅谈多线程同步01 --- --- 互斥锁、条件变量、信号量和读写锁
Boss_peng的博客
06-05 442
浅谈多线程同步01 --- --- 互斥锁、条件变量、信号量和读写锁
详解linux多线程——互斥锁、条件变量、读写锁、自旋锁、信号量
Linuxhus的博客
11-03 299
如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。3. 非繁忙等待：如果一个线程已经锁定了一个互斥量，第二个线程又试图去锁定这个互斥量，则第二个线程将被挂起（不占用任何cpu资源），直到第一个线程解除对这个互斥量的锁定为止，第二个线程则被唤醒并继续执行，同时锁定这个互斥量。在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。
条件变量和读写锁实现线程同步
05-24
//windows核心编程5th 生产者部分 请求独占锁锁 AcquireSRWLockExclusive(&g_srwLock) 程序处于运行状态,并且数据已满:生产者转入休眠状态 SleepConditionVariableSRW(&g_cvReadyToProduce, &g_srwLock, INFINITE, 0); 程序停止工作:释放独占锁并且唤醒其它生产者退出程序ReleaseSRWLockExclusive(&g_srwLock); WakeAllConditionVariable(&g_cvReadyToProduce); 否则:释放独占锁并且唤醒一个消费者 ReleaseSRWLockExclusive(&g_srwLock); WakeAllConditionVariable(&g_cvReadyToConsume);
互斥锁、自旋锁、读写锁、条件锁、悲观锁、乐观锁
pipi糖的博客
04-30 978
一. 互斥锁（Mutex） 互斥锁用于控制多个线程对他们之间共享资源互斥访问的一个信号量。也就是说是为了避免多个线程在某一时刻同时操作（如修改）一个共享资源。如果占用共享资源的线程释放互斥量时，有一个以上的线程阻塞，那么所有该锁上的阻塞线程进入准备就绪状态（其中也包括释放锁的线程，该线程也会进入就绪队列），准备就绪状态的所有线程，通过竞争，进入运行状态，然后竞争获取锁资源。 二. 自旋锁（Mutex） 自旋锁是一种非阻塞锁，也就是说，如果某线程需要获取自旋锁，但该锁已经被其他线程占用时，该线程不会被挂起（不
Linux互斥锁、条件变量和信号量
seven407的专栏
03-09 695
Linux互斥锁、条件变量和信号量： 转自：http://hi.baidu.com/yanxionglu/blog/item/a3eafdece87015f0b2fb95cd.html 进行多线程编程，最应该注意的就是那些共享的数据，因为无法知道哪个线程会在哪个时候对它进行操作，也无法得知哪个线程会先运行，哪个线程会后运行。所以，要对这些资源进行合理的分配和正确的使用。在Linux下，提供了互斥锁、条件变量和信号量来对共享资源进行保护。 一、互斥锁 互斥锁，是一种信号量，常用来防止两个进程或线程在同一时
请用普通的互斥锁编程实现一个读写锁
wwhhff11
03-17 2124
参考 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;public class Main { //写锁 private static Lock writer_lock=new ReentrantLock(); private static volatil
linux下用互斥锁和条件变量来实现读写锁
Yannie's Blog
11-02 377
以下内容来源自UNP卷二的第八章 读写锁的概念( the conception of read-write lock ) (1)只要没有线程持有某个给定的读写锁用于写，那么任意数目的线程可以持有该线程用于读 (2)仅当没有线程持有某个给定的读写锁用于读或用于写，才能分配该读写锁用于写 这种给定资源的共享访问方式也叫做共享-独占上锁 因为获取一个读写锁用于读是共享锁，获取一个读写锁用于写是独占锁。 ...
使用互斥锁和条件变量实现实现读写锁
Coolmonster的博客
11-10 857
只需要使用互斥锁和条件变量就能实现写者优先的读写锁。 头文件pthread_rwlock_t .h的实现: #ifdef _MY_PTHREAD_RWLOCK_H #define _MY_PTHREAD_RWLOCK_H #include #include #include #include enum{ENIVAL}; typedef struct{ pthread_mutex_t
基于互斥锁和条件变量实现读写锁，写优先
wwdwwd的专栏
07-17 930
#include #include #include #include class MyRWLock { public: MyRWLock():_stat(0),_have_wlock_wait(false){ pthread_mutex_init(&_mutex,NULL); pthread_cond_init(&_cond,NULL); } ~MyRWL
Linux使用互斥锁和条件变量实现读写锁（读优先）
manonghouyiming的博客
03-31 998
本篇博客结合上篇读写锁（写优先）//my_pthread_rwlock.h #pragma once #include&lt;pthread.h&gt; #include&lt;stdio.h&gt; typedef struct { pthread_mutex_t rw_mutex; pthread_cond_t rw_condreaders; pthread_c...
PHP程序中的锁机制解析：文件锁、互斥锁与读写锁
sync模块提供了一套高级的同步原语，如互斥锁、条件变量等，适用于多线程环境。pthreads扩展则允许在PHP中创建和操作线程，它引入了互斥锁、读写锁以及线程安全的数据结构，使PHP具备了多线程编程的能力。 在实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值