设为首页收藏本站
切换到窄版

 找回密码
 用户注册

QQ登录

只需一步，快速开始

ACE Developer»论坛 › 开发基础 › C/C++学习 › 在Win32下用C++实现多线程读写锁
返回列表 发新帖
查看: 3881|回复: 0

在Win32下用C++实现多线程读写锁

[复制链接]
发表于 2011-12-29 10:18:29 | 显示全部楼层 |阅读模式
    读写锁实际是一种特殊的自旋锁，它把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作。这种锁相对于自旋锁而言，能提高并发性，因为在多处理器系统中，它允许同时有多个读者来访问共享资源，最大可能的读者数为实际的逻辑CPU数。写者是排他性的，一个读写锁同时只能有一个写者或多个读者（与CPU数相关），但不能同时既有读者又有写者。
    现在Win32的API，用C++实现自己的读写锁。这组API包括：CreateMutex，CreateEvent，WaitForSingleObject，WaitForMultipleObjects，ResetEvent，ReleaseMutex，SetEvent，CloseHandle。以下代码在VS2005下，已经编译通过。
RWLockImpl.h
  2. #ifndef _RWLockImpl_Header
  3. #define _RWLockImpl_Header
  5. #include <assert.h>
  6. #include <iostream>
  7. #include <Windows.h>
  8. #include <process.h>
  10. using namespace std;
  12. /*
  13. 读写锁允许当前的多个读用户访问保护资源，但只允许一个写读者访问保护资源
  14. */
  16. //-----------------------------------------------------------------
  17. class CRWLockImpl
  18. {
  19. protected:
  20.         CRWLockImpl();
  21.         ~CRWLockImpl();
  22.         void ReadLockImpl();
  23.         bool TryReadLockImpl();
  24.         void WriteLockImpl();
  25.         bool TryWriteLockImpl();
  26.         void UnlockImpl();
  28. private:
  29.         void AddWriter();
  30.         void RemoveWriter();
  31.         DWORD TryReadLockOnce();
  33.         HANDLE   m_mutex;
  34.         HANDLE   m_readEvent;
  35.         HANDLE   m_writeEvent;
  36.         unsigned m_readers;
  37.         unsigned m_writersWaiting;
  38.         unsigned m_writers;
  39. };
  41. //-----------------------------------------------------------------
  43. class CMyRWLock: private CRWLockImpl
  44. {
  45. public:
  47.         //创建读/写锁
  48.         CMyRWLock(){};
  50.         //销毁读/写锁
  51.         ~CMyRWLock(){};
  53.         //获取读锁
  54.         //如果其它一个线程占有写锁，则当前线程必须等待写锁被释放，才能对保护资源进行访问
  55.         void ReadLock();
  57.         //尝试获取一个读锁
  58.         //如果获取成功，则立即返回true，否则当另一个线程占有写锁，则返回false
  59.         bool TryReadLock();
  61.         //获取写锁
  62.         //如果一个或更多线程占有读锁，则必须等待所有锁被释放
  63.         //如果相同的一个线程已经占有一个读锁或写锁，则返回结果不确定
  64.         void WriteLock();
  66.         //尝试获取一个写锁
  67.         //如果获取成功，则立即返回true，否则当一个或更多其它线程占有读锁，返回false
  68.         //如果相同的一个线程已经占有一个读锁或写锁，则返回结果不确定
  69.         bool TryWriteLock();
  71.         //释放一个读锁或写锁
  72.         void Unlock();
  74. private:
  75.         CMyRWLock(const CMyRWLock&);
  76.         CMyRWLock& operator = (const CMyRWLock&);
  77. };
  79. inline void CMyRWLock::ReadLock()
  80. {
  81.         ReadLockImpl();
  82. }
  84. inline bool CMyRWLock::TryReadLock()
  85. {
  86.         return TryReadLockImpl();
  87. }
  89. inline void CMyRWLock::WriteLock()
  90. {
  91.         WriteLockImpl();
  92. }
  94. inline bool CMyRWLock::TryWriteLock()
  95. {
  96.         return TryWriteLockImpl();
  97. }
  99. inline void CMyRWLock::Unlock()
  100. {
  101.         UnlockImpl();
  102. }
  105. #endif
复制代码
RWLockImpl.cpp
  2. #include "RWLockImpl.h"
  4. CRWLockImpl::CRWLockImpl(): m_readers(0), m_writersWaiting(0), m_writers(0)
  5. {
  6.         m_mutex = CreateMutex(NULL, FALSE, NULL);
  7.         if (m_mutex == NULL)
  8.                 cout<<"cannot create reader/writer lock"<<endl;
  10.         m_readEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
  11.         if (m_readEvent == NULL)
  12.                 cout<<"cannot create reader/writer lock"<<endl;
  14.         m_writeEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
  15.         if (m_writeEvent == NULL)
  16.                 cout<<"cannot create reader/writer lock"<<endl;
  17. }
  19. CRWLockImpl::~CRWLockImpl()
  20. {
  21.         CloseHandle(m_mutex);
  22.         CloseHandle(m_readEvent);
  23.         CloseHandle(m_writeEvent);
  24. }
  26. inline void CRWLockImpl::AddWriter()
  27. {
  28.         switch (WaitForSingleObject(m_mutex, INFINITE))
  29.         {
  30.         case WAIT_OBJECT_0:
  31.                 if (++m_writersWaiting == 1)
  32.                         ResetEvent(m_readEvent);
  33.                 ReleaseMutex(m_mutex);
  34.                 break;
  35.         default:
  36.                 cout<<"cannot lock reader/writer lock"<<endl;
  37.         }
  38. }
  40. inline void CRWLockImpl::RemoveWriter()
  41. {
  42.         switch (WaitForSingleObject(m_mutex, INFINITE))
  43.         {
  44.         case WAIT_OBJECT_0:
  45.                 if (--m_writersWaiting == 0 && m_writers == 0)
  46.                         SetEvent(m_readEvent);
  47.                 ReleaseMutex(m_mutex);
  48.                 break;
  49.         default:
  50.                 cout<<"cannot lock reader/writer lock"<<endl;
  51.         }
  52. }
  54. void CRWLockImpl::ReadLockImpl()
  55. {
  56.         HANDLE h[2];
  57.         h[0] = m_mutex;
  58.         h[1] = m_readEvent;
  59.         switch (WaitForMultipleObjects(2, h, TRUE, INFINITE))
  60.         {
  61.         case WAIT_OBJECT_0:
  62.         case WAIT_OBJECT_0 + 1:
  63.                 ++m_readers;
  64.                 ResetEvent(m_writeEvent);
  65.                 ReleaseMutex(m_mutex);
  66.                 assert(m_writers == 0);
  67.                 break;
  68.         default:
  69.                 cout<<"cannot lock reader/writer lock"<<endl;
  70.         }
  71. }
  73. bool CRWLockImpl::TryReadLockImpl()
  74. {
  75.         for (;;)
  76.         {
  77.                 if (m_writers != 0 || m_writersWaiting != 0)
  78.                         return false;
  80.                 DWORD result = TryReadLockOnce();
  81.                 switch (result)
  82.                 {
  83.                 case WAIT_OBJECT_0:
  84.                 case WAIT_OBJECT_0 + 1:
  85.                         return true;
  86.                 case WAIT_TIMEOUT:
  87.                         continue;
  88.                 default:
  89.                         cout<<"cannot lock reader/writer lock"<<endl;
  90.                 }
  91.         }
  92. }
  94. void CRWLockImpl::WriteLockImpl()
  95. {
  96.         AddWriter();
  97.         HANDLE h[2];
  98.         h[0] = m_mutex;
  99.         h[1] = m_writeEvent;
  100.         switch (WaitForMultipleObjects(2, h, TRUE, INFINITE))
  101.         {
  102.         case WAIT_OBJECT_0:
  103.         case WAIT_OBJECT_0 + 1:
  104.                 --m_writersWaiting;
  105.                 ++m_readers;
  106.                 ++m_writers;
  107.                 ResetEvent(m_readEvent);
  108.                 ResetEvent(m_writeEvent);
  109.                 ReleaseMutex(m_mutex);
  110.                 assert(m_writers == 1);
  111.                 break;
  112.         default:
  113.                 RemoveWriter();
  114.                 cout<<"cannot lock reader/writer lock"<<endl;
  115.         }
  116. }
  118. bool CRWLockImpl::TryWriteLockImpl()
  119. {
  120.         AddWriter();
  121.         HANDLE h[2];
  122.         h[0] = m_mutex;
  123.         h[1] = m_writeEvent;
  124.         switch (WaitForMultipleObjects(2, h, TRUE, 1))
  125.         {
  126.         case WAIT_OBJECT_0:
  127.         case WAIT_OBJECT_0 + 1:
  128.                 --m_writersWaiting;
  129.                 ++m_readers;
  130.                 ++m_writers;
  131.                 ResetEvent(m_readEvent);
  132.                 ResetEvent(m_writeEvent);
  133.                 ReleaseMutex(m_mutex);
  134.                 assert(m_writers == 1);
  135.                 return true;
  136.         case WAIT_TIMEOUT:
  137.                 RemoveWriter();
  138.         default:
  139.                 RemoveWriter();
  140.                 cout<<"cannot lock reader/writer lock"<<endl;
  141.         }
  142.         return false;
  143. }
  145. void CRWLockImpl::UnlockImpl()
  146. {
  147.         switch (WaitForSingleObject(m_mutex, INFINITE))
  148.         {
  149.         case WAIT_OBJECT_0:
  150.                 m_writers = 0;
  151.                 if (m_writersWaiting == 0) SetEvent(m_readEvent);
  152.                 if (--m_readers == 0) SetEvent(m_writeEvent);
  153.                 ReleaseMutex(m_mutex);
  154.                 break;
  155.         default:
  156.                 cout<<"cannot unlock reader/writer lock"<<endl;
  157.         }
  158. }
  160. DWORD CRWLockImpl::TryReadLockOnce()
  161. {
  162.         HANDLE h[2];
  163.         h[0] = m_mutex;
  164.         h[1] = m_readEvent;
  165.         DWORD result = WaitForMultipleObjects(2, h, TRUE, 1);
  166.         switch (result)
  167.         {
  168.         case WAIT_OBJECT_0:
  169.         case WAIT_OBJECT_0 + 1:
  170.                 ++m_readers;
  171.                 ResetEvent(m_writeEvent);
  172.                 ReleaseMutex(m_mutex);
  173.                 assert(m_writers == 0);
  174.                 return result;
  175.         case WAIT_TIMEOUT:
  176.         default:
  177.                 cout<<"cannot lock reader/writer lock"<<endl;
  178.         }
  179.         return result;
  180. }
复制代码
    下边是测试代码

// MyRWLockWin32.cpp : 定义控制台应用程序的入口点。//
  3. #include "RWLockImpl.h"
  5. //创建一个读写锁对象
  6. CMyRWLock g_myRWLock;
  7. volatile int g_counter = 0;
  9. //线程函数
  10. unsigned int __stdcall StartThread(void *pParam)
  11. {
  12.         int lastCount = 0;
  13.         for (int i = 0; i < 10000; ++i)
  14.         {
  15.                 g_myRWLock.ReadLock();
  16.                 lastCount = g_counter;
  17.                 //在读锁域，两个线程不断循环交替访问全局变量g_counter
  18.                 for (int k = 0; k < 100; ++k)
  19.                 {
  20.                         if (g_counter != lastCount)
  21.                                 cout<<"the value of g_counter has been updated."<<endl;
  22.                         Sleep(0);
  23.                 }
  24.                 g_myRWLock.Unlock();
  27.                 g_myRWLock.WriteLock();
  28.                 //在写锁域，只有一个线程可以修改全局变量g_counter的值
  29.                 for (int k = 0; k < 100; ++k)
  30.                 {
  31.                         --g_counter;
  32.                         Sleep(0);
  33.                 }
  34.                 for (int k = 0; k < 100; ++k)
  35.                 {
  36.                         ++g_counter;
  37.                         Sleep(0);
  38.                 }
  39.                 ++g_counter;
  40.                 if (g_counter <= lastCount)
  41.                         cout<<"the value of g_counter is error."<<endl;
  42.                 g_myRWLock.Unlock();
  43.         }
  44.        
  45.         return (unsigned int)0;
  46. }
  48. int main(int argc, char* argv[])
  49. {
  50.         HANDLE hThread1, hThread2;
  51.         unsigned int uiThreadId1, uiThreadId2;
  53.         //创建两个工作线程
  54.         hThread1 = (HANDLE)_beginthreadex(NULL, 0, &StartThread, (void *)NULL, 0, &uiThreadId1);
  55.         hThread2 = (HANDLE)_beginthreadex(NULL, 0, &StartThread, (void *)NULL, 0, &uiThreadId2);
  57.         //等待线程结束
  58.         DWORD dwRet = WaitForSingleObject(hThread1,INFINITE);
  59.         if ( dwRet == WAIT_TIMEOUT )
  60.         {
  61.                 TerminateThread(hThread1,0);
  62.         }
  63.         dwRet = WaitForSingleObject(hThread2,INFINITE);
  64.         if ( dwRet == WAIT_TIMEOUT )
  65.         {
  66.                 TerminateThread(hThread2,0);
  67.         }
  69.         //关闭线程句柄，释放资源
  70.         CloseHandle(hThread1);
  71.         CloseHandle(hThread2);
  73.         assert (g_counter == 20000);
  75.         system("pause");
  76.         return 0;
  77. }
复制代码

    欢迎转载，麻烦带上链接：http://blog.csdn.net/chexlong/article/details/7110060 谢谢合作！




作者：chexlong 发表于2011-12-28 21:27:40 原文链接
傲游高品质VPS主机，特价促销
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 用户注册

本版积分规则

Archiver|手机版|小黑屋|ACE Developer ( 京ICP备06055248号 )

GMT+8, 2024-12-22 18:47 , Processed in 0.023509 second(s), 7 queries , Redis On.

Powered by Discuz! X3.5

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表