秒杀多线程第十篇 读者写者问题

最新推荐文章于 2022-08-02 11:26:33 发布
最新推荐文章于 2022-08-02 11:26:33 发布
阅读量336 收藏
点赞数 1
分类专栏： Windows编程之多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ygl840455828ygl/article/details/52297060
版权

下面利用信号量和互斥量来做一个读写锁类，代码如下：

//
//读写锁
功能：该类为多线程做对资源的读写锁，其中信号量用来读写互斥和写写互斥，互斥量用来读读互斥
思路概要：看代码中的注释可知
//
#include "StdAfx.h"
#include "RWLock.h"
//

#ifndef FALSE 
#define FALSE 0
#endif

#ifndef TRUE
#define TRUE 1
#endif

//完成读写锁初始化
CRWLock::CRWLock()
{

	InitRWLock();
	
}

//
CRWLock::~CRWLock()
{
	DestroyRWLock();
}

BOOL  CRWLock::MyWaitForSingleObject(HANDLE hObject)
{
#ifdef WIN32

	DWORD result;

	result = WaitForSingleObject(hObject, INFINITE);

	return (result == WAIT_OBJECT_0);

#endif
}

BOOL  CRWLock::InitRWLock()
{
#ifdef WIN32

	m_RWLock.nReaderCount = 0;
	m_RWLock.hDataLock = CreateSemaphore(NULL, 1, 1, NULL);//初始化创建信号量，在信号量的介绍中有对其参数的解释，此处不多做介绍，
	//这里初始化资源个数为1，如果先做读操作请求的话，及时没有先写也会请求成功，个人觉得改为0比较好
	if (m_RWLock.hDataLock == NULL)
	{
		return FALSE;
	}

	m_RWLock.hMutex = CreateMutex(NULL, FALSE, NULL);//第二个参数为false，表明互斥量不为任何线程占用，处于触发状态。
	if (m_RWLock.hMutex == NULL)
	{
		CloseHandle(m_RWLock.hDataLock);
		return FALSE;
	}

	return TRUE;

#else

	 pthread_rwlock_init(&m_RWLock, NULL);

	 return TRUE;
#endif

}

BOOL  CRWLock::DestroyRWLock()
{
#ifdef WIN32

	DWORD result = WaitForSingleObject(m_RWLock.hDataLock, INFINITE);
	if (result != WAIT_OBJECT_0)
	{
		return FALSE;
	}

	CloseHandle(m_RWLock.hMutex);
	CloseHandle(m_RWLock.hDataLock);
	return TRUE;

#else

	pthread_rwlock_destroy(&m_RWLock);

	return TRUE;

#endif
}

BOOL CRWLock::AcquireReadLock()//请求读操作
{
	BOOL result = TRUE;

#ifdef WIN32

	if (MyWaitForSingleObject(m_RWLock.hMutex) == FALSE)//阻塞等待互斥量m_RWLock.hMutex被触发
	{
		return FALSE;
	}

	m_RWLock.nReaderCount ++;
	if(m_RWLock.nReaderCount == 1)
	{
		result = MyWaitForSingleObject(m_RWLock.hDataLock);//当是第一个读的时候，阻塞等待信号量计数大于0，即做过写操作有数据可读，然后对信号量--，
	}

    /***此处做读操作***/

	ReleaseMutex(m_RWLock.hMutex);//触发互斥量

	return result;

#else
	pthread_rwlock_rdlock(&m_RWLock);

	return result;
#endif
}


BOOL CRWLock::ReleaseReadLock()
{
	int result = TRUE;

#ifdef WIN32

	LONG lPrevCount;

	if (MyWaitForSingleObject(m_RWLock.hMutex) == FALSE)//阻塞等待互斥量m_RWLock.hMutex被触发
	{
		return FALSE;
	}

	--m_RWLock.nReaderCount;

	if (m_RWLock.nReaderCount == 0)
	{
		result = ReleaseSemaphore(m_RWLock.hDataLock, 1, &lPrevCount);//如果为最后一个读者则信号量++，通知其他线程没有线程在做读操作，此时可以做写操作了
	}

	ReleaseMutex(m_RWLock.hMutex);//触发互斥量，来通知此次读操作以完成，其他线程可做读操作

	return result;
#else

	return pthread_rwlock_unlock(&m_RWLock);	

#endif
}

BOOL CRWLock::AcquireWriteLock()
{

#ifdef WIN32

	return MyWaitForSingleObject(m_RWLock.hDataLock);//可理解为等待信号量被触发，来源为ReleaseWriteLock中触发（即写操作以完成）或145行的读操作以完成

#else
	
	return pthread_rwlock_wrlock(&m_RWLock);

#endif
}


BOOL CRWLock::ReleaseWriteLock()
{
#ifdef WIN32

	int result = TRUE;
	LONG lPrevCount;

	result = ReleaseSemaphore(m_RWLock.hDataLock, 1, &lPrevCount);//信号量++，来通知其他线程本次写操作以完成，可以做读操作或写操作了
	if (lPrevCount != 0)
	{
		return FALSE;
	}

	return result;

#else
	return  pthread_rwlock_unlock(&m_RWLock);
#endif
}
//
//读写锁

//
#ifndef  _RWMETUX_H_
#define  _RWMETUX_H_

//
#ifndef  WIN32
  #include 
   
   
    
    
#endif

//
// 多证书链读写锁类
#ifdef  WIN32

typedef struct _RWLock
{
	HANDLE	hMutex;    
	HANDLE	hDataLock;
	int		nReaderCount;
} RWLock;

#endif

class  CRWLock
{
public:
	CRWLock();
	~CRWLock();

	BOOL  AcquireReadLock(void);    //请求读操作锁,请求不成功则阻塞
	BOOL  ReleaseReadLock(void);    //释放读操作锁

	BOOL  AcquireWriteLock(void);   //请求写操作锁,请求不成功则阻塞
	BOOL  ReleaseWriteLock(void);   //释放写操作锁

private:
	BOOL  CRWLock::MyWaitForSingleObject(HANDLE hObject);
	BOOL  CRWLock::InitRWLock();
	BOOL  CRWLock::DestroyRWLock();
private:

#ifdef  WIN32
	RWLock	m_RWLock;   //读写锁
#else
	pthread_rwlock_t m_RWLock;
#endif
	
};

#endif   //_RWMETUX_H_

看了一下我转载的这些文章的作者写的秒杀多线程第十一篇 读者写者问题  这个对读写锁操作的列子，是存在问题的。第十一篇中的评论：“确实有这个问题存在。 g_hEventNoReader = CreateEvent(NULL, FALSE, TRUE, NULL); 这句使得写线程一开始就得到 WaitForSingleObject(g_hEventNoReader, INFINITE)成功执行的机会，如果在读线程对 g_nReaderCount进行修改之前让读线程Sleep(),则会出现既在读又在写的情况。”这个是存在的，导致这个的原因主要是 g_hEventWriter = CreateEvent(NULL, TRUE, TRUE, NULL); 第二个参数他设置为TRUE导致WaitForSingleObject不会把事件设置为未触发状态，而此时读线程也可以继续执行，导致读写的恶性竞争。其次第十四篇中秒杀多线程第十四篇 读者写者问题继 读写锁SRWLock  由于用到了SRWLock所以解决了这个问题，这个读写锁内部做了相应的操作吧！在此贴出这为大神的代码：

//读者与写者问题继 读写锁SRWLock
#include 
   
   
    
    
#include 
    
    
     
     
#include 
     
     
      
      
//设置控制台输出颜色
BOOL SetConsoleColor(WORD wAttributes)
{
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	if (hConsole == INVALID_HANDLE_VALUE)
		return FALSE;
	return SetConsoleTextAttribute(hConsole, wAttributes);
}
const int READER_NUM = 5;  //读者个数
//关键段和事件
CRITICAL_SECTION g_cs;
SRWLOCK          g_srwLock; 
//读者线程输出函数(变参函数的实现)
void ReaderPrintf(char *pszFormat, ...)
{
	va_list   pArgList;
	va_start(pArgList, pszFormat);
	EnterCriticalSection(&g_cs);
	vfprintf(stdout, pszFormat, pArgList);
	LeaveCriticalSection(&g_cs);
	va_end(pArgList);
}
//读者线程函数
unsigned int __stdcall ReaderThreadFun(PVOID pM)
{
	ReaderPrintf("     编号为%d的读者进入等待中...\n", GetCurrentThreadId());
	//读者申请读取文件
	AcquireSRWLockShared(&g_srwLock);

	//读取文件
	ReaderPrintf("编号为%d的读者开始读取文件...\n", GetCurrentThreadId());
	Sleep(rand() % 100);
	ReaderPrintf(" 编号为%d的读者结束读取文件\n", GetCurrentThreadId());

	//读者结束读取文件
	ReleaseSRWLockShared(&g_srwLock);
	return 0;
}
//写者线程输出函数
void WriterPrintf(char *pszStr)
{
	EnterCriticalSection(&g_cs);
	SetConsoleColor(FOREGROUND_GREEN);
	printf("     %s\n", pszStr);
	SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
	LeaveCriticalSection(&g_cs);
}
//写者线程函数
unsigned int __stdcall WriterThreadFun(PVOID pM)
{
	WriterPrintf("写者线程进入等待中...");
	//写者申请写文件
	AcquireSRWLockExclusive(&g_srwLock);
		
	//写文件
	WriterPrintf("  写者开始写文件.....");
	Sleep(rand() % 100);
	WriterPrintf("  写者结束写文件");

	//标记写者结束写文件
	ReleaseSRWLockExclusive(&g_srwLock);
	return 0;
}
int main()
{
	printf("  读者写者问题继 读写锁SRWLock\n");
	printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");

	//初始化读写锁和关键段
	InitializeCriticalSection(&g_cs);
	InitializeSRWLock(&g_srwLock);

	HANDLE hThread[READER_NUM + 1];
	int i;
	//先启动二个读者线程
	for (i = 1; i <= 2; i++)
		hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);
	//启动写者线程
	hThread[0] = (HANDLE)_beginthreadex(NULL, 0, WriterThreadFun, NULL, 0, NULL);
	Sleep(50);
	//最后启动其它读者结程
	for ( ; i <= READER_NUM; i++)
		hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);
	WaitForMultipleObjects(READER_NUM + 1, hThread, TRUE, INFINITE);
	for (i = 0; i < READER_NUM + 1; i++)
		CloseHandle(hThread[i]);

	//销毁关键段
	DeleteCriticalSection(&g_cs);
	return 0;
}

ygl840455828ygl
关注
专栏目录
12.[个人]C++线程入门到进阶（12）----读者写者问题&读写锁SRWLock
shuimanting520的博客
04-25 881
与上一篇《秒杀多线程第十篇 生产者消费者问题》的生产者消费者问题一样，读者写者也是一个非常著名的同步问题。读者写者问题描述非常简单，有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读文件，同样有读者在读文件时写者也不去能写文件。 上面是读者写者问题示意图，类似于生产者消费者问题的分析过程，首先来找找哪些是属于“等待”情况。 第一．写者要等到没有读者时才能去
14.[个人]C++线程入门到进阶（14）----双线程读写队列数据
shuimanting520的博客
04-25 2715
本文配套程序下载地址为：http://download.csdn.net/detail/morewindows/5136035 转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/8646902 欢迎关注微博：http://weibo.com/MoreWindows   在《秒杀多线程系列》的前十五篇中介绍多线程的相关
多线程模拟读者写者问题，采用读写平等方式
07-18
操作系统课程设计采用读写平等实现的读者写者问题。
多线程---读者写者问题
琼华
07-05 2490
读者写者的几种实现方法
Linux入门篇——多线程之读者写者模型
qq_56101220的博客
08-02 180
读者写者模型及相关函数
c# 多线程学习笔记（五）读者写者问题
mochounv的专栏
08-23 1133
问题描述 读者写者也是一个非常著名的同步问题，也叫共享独占锁。问题描述非常简单，有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读文件，同样有读者在读文件时写者也不去能写文件。因此要求：①允许多个读者可以同时对文件执行读操作；②同时只允许一个写者往文件中写信息；③任一写者在完成写操作之前不允许其他读者或写者工作；④写者执行写操作前，应让已有的读者和写者全部退出。
wav文件降噪c语言,语音降噪
weixin_30460749的博客
05-24 520
一个频域维纳滤语语音降噪实现，完整的工程实现可以到音视频算法讨论群(374737122)中下载并讨论1.[文件] ns.c~7KB 下载(55)// 本文来自于icoolmedia，相关算法QQ交流群为：374737122#include "ns.h"#include "fftwrap.h"struct NoiseReduction_t{OsInt32 sample_rate;OsIn...
windows多线程详解
遇见--专栏
08-10 521
在一个牛人的博客上看到了这篇文章，所以就转过来了，地址是http://blog.csdn.net/morewindows/article/details/7421759 本文将带领你与多线程作第一次亲密接触，并深入分析CreateThread与_beginthreadex的本质区别，相信阅读本文后你能轻松的使用多线程并能流畅准确的回答CreateThread与_beginthreadex到底
了解SynchronousQueue在多线程协作中的应用
## 1.1 介绍多线程协作问题 在多线程编程中，经常会遇到多个线程之间需要协作完成某个任务的情况。这种协作可能涉及到数据的传递、任务的执行顺序控制或者资源的共享。然而，线程之间的协作需要合理的机制来保证...
linux-多线程--面试题
热门推荐
雨夜聆风的专栏
05-21 1万+
刚无意中看到MoreWindows博主秒杀多线程面试题（http://blog.csdn.net/column/details/killthreadseries.html），第一篇就有他收集的面试题。那我就用来检验一下自己学的怎么样吧。     前面的选择题那些跳过，直接看最后的编程题。 第三题（某培训机构的练习题）： 子线程循环 10 次，接着主线程循环 100 次，接着又回到子线
Windows平台下的读写锁
tifentan的专栏
01-02 1931
Windows平台下的读写锁 简单介绍Windows平台下的读写锁以及实现.背景介绍 Windows在Vista 和 Server2008以后才开始提供读写锁API,即SRW系列函数(InitializeSRWLock, AcquireSRWLockShared, AcquireSRWLockExclusive等).考虑到目前Windows XP的装机量,只能自己实现一个读写锁了.读写锁的目的和
秒杀多线程第十四篇 读者写者问题继 读写锁SRWLock
huobengluantiao8
06-13 271
在《秒杀多线程第十一篇读者写者问题》文章中我们使用事件和一个记录读者个数的变量来解决读者写者问题。问题虽然得到了解决，但代码有点复杂。本篇将介绍一种新方法——读写锁SRWLock来解决这一问题。读写锁在对资源进行保护的同时，还能区分想要读取资源值的线程（读取者线程）和想要更新资源的线程（写入者线程）。对于读取者线程，读写锁会允许他们并发的执行。当有写入者线程在占有资源时，读写锁会让其它写入者线程...
Win32 实现读写锁
Emacs的专栏
03-04 2416
Win32中没有为Xp提供读写锁机制（只为Vista提供了）， 由于工作需求，所以自己实现了一个简单的读写锁，具体实现如下：头文件：rwlocker.h#ifndef _RWLOCKER_H_#define _RWLOCKER_H_#include namespace Locker{ class RWLocker { private: unsigned l
读者写者java多线程_Java 多线程读者写者问题
weixin_42515372的博客
02-26 217
/** 读者写者问题** */import java.util.concurrent.locks.*;class Buffer{public int buffer[]=new int [10];//用于标识共享的缓冲区public boolean flag=false;//用于标识缓冲区的状态public int i;//表示向缓冲区写的位置}class Writer implemen...
C++在win32实现读写锁
koln频道
09-20 510
http://blog.csdn.net/u014805066/article/details/60755567
Linux多线程──读者写者问题
fuerbosi
07-12 549
读者写者问题 这也是一个非常经典的多线程题目，题目大意如下：有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读文件，同样有读者读时写者也不能写。 程序： // reader_writer.cpp ////////////////////////////////////////////////////////////////////// // 读者写...
【多线程】(十)读者写者问题
Row Row Row your boat
11-08 2076
参考自： http://blog.csdn.net/morewindows/article/details/7596034#     读者写者问题描述非常简单，有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读文件，同样有读者在读文件时写者也不去能写文件。 上面是读者写者问题示意图，类似于生产者消费者问题的分析过程，首先来找找哪些是属于“等待”情况。 第
操作系统之多线程编程—读者优先/写者优先详解
bigsai
12-04 9106
操作系统之进程调度——优先权法和轮转法（附上样例讲解） 操作系统之银行家算法—详解流程及案例数据 操作系统之多线程编程—读者优先/写者优先详解 操作系统之存储管理——FIFO算法和LRU算法 操作系统之磁盘调度——SCAN实例讲解 一、实验目的 1、熟悉多线程编程 2、熟悉使用信号量机制解决进程同步问题 二、实验内容 创建一个包含n 个线程的控制台进程。用这n 个线程来表示...
Windows环境下读者写者问题的多线程实现
"操作系统读者写者问题实验报告，包含了程序源码、实验结果图，旨在通过实际编程加深对进程和线程管理的理解，特别是聚焦于Windows多线程编程。实验中，利用信号量解决了经典的读者写者问题，讨论了读者优先和写者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值