Win32/C++ 跨进程读写锁

已于 2025-02-10 13:26:26 修改
阅读量305 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： Windows Win32 C++ 文章标签： 读写锁 跨进程读写锁 C++ Win32 Windows 共享内存
于 2024-12-29 22:43:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Flame_Cyclone/article/details/144811981

使用信号量, 互斥量,  事件, 共享内存组合实现的跨进程读写锁

1.写入锁定时任何读取将会挂起

2.读取锁定时任何写入将会挂起

3.写入无锁时任何读取不会挂起

4.多个读取挂起, 多个写入挂起, 单个写入锁定时, 若解锁, 挂起的写入操作优先获得锁

CRWLockIPC.h

#pragma once

#include <windows.h>
#include <vector>
#include <string>
#include <tchar.h>

#pragma warning(disable:4200)

#ifdef _UNICODE
using _tstring = std::wstring;
#else
using _tstring = std::string;
#endif

//
// @brief: 跨进程读写锁
// @copyright: Copyright 2024 FlameCyclone
// @license: 
// @birth: Created by Visual Studio 2022 on 2024-12-29
// @version: V1.0.0
// @revision: last revised by FlameCyclone on 2024-12-29
//

class CRWLockIPC
{
public:

    CRWLockIPC();
    ~CRWLockIPC();

    //
    // @brief: 初始化
    // @param: strName          锁名, 如果无锁名, 则不可跨进程
    // @param: fWritePriority   是否写操作优先
    // @param: nReadCount       最大同时读取计数
    // @ret: bool
    bool Initialize(
        const _tstring& strName = _T(""), 
        bool fWritePriority = true,
        LONG nReadCount = LONG_MAX
    );

    //
    // @brief: 反初始化
    // @ret: void
    void Uninitialize();

    //
    // @brief: 获取读锁
    // @param: dwTimeout    超时时间(毫秒)
    // @ret: bool           获取是否成功
    bool AcquireReadLock(DWORD dwTimeout = INFINITE);

    //
    // @brief: 释放读锁
    // @ret: void
    void ReleaseReadLock();

    //
    // @brief: 获取写锁
    // @param: dwTimeout    超时时间(毫秒)
    // @ret: bool           获取是否成功
    bool AcquireWriteLock(DWORD dwTimeout = INFINITE);

    //
    // @brief: 释放写锁
    // @ret: void
    void ReleaseWriteLock();

private:

    // 共享数据结构
    typedef struct _SHARE_DATA
    {
        LONG nReadWaitCount;                    // 当前读取等待计数
        LONG nWriteWaitCount;                   // 当前写入等待计数
        LONG nReadCount;                        // 当前读取计数
        LONG nWriteCount;                       // 当前写入计数
    }SHARE_DATA, * PSHARE_DATA;

    PSHARE_DATA m_pShareData;                   // 共享数据(用于共享数据结构存取)
    HANDLE m_hFileMapping;                      // 共享内存(文件映射)
    HANDLE m_hReadSemaphore;                    // 读取信号量
    HANDLE m_hWritableEvent;                    // 可写事件(无读取时有信号)
    HANDLE m_hReadableEvent;                    // 可读事件(无写入时有信号)
    HANDLE m_hWriteMutex;                       // 写入互斥量
    HANDLE m_hShareMutex;                       // 共享数据互斥量
    bool   m_fInit;                             // 初始化结果
    bool   m_fWritePriority;                    // 写优先
};

CRWLockIPC.cpp

#include "CRWLockIPC.h"

CRWLockIPC::CRWLockIPC()
    :
    m_pShareData(nullptr),
    m_hFileMapping(nullptr),
    m_hReadSemaphore(nullptr),
    m_hWritableEvent(nullptr),
    m_hReadableEvent(nullptr),
    m_hWriteMutex(nullptr),
    m_hShareMutex(nullptr),
    m_fInit(false),
    m_fWritePriority(false)
{

}

CRWLockIPC::~CRWLockIPC()
{
    Uninitialize();
}

bool CRWLockIPC::Initialize(
    const _tstring& strName,
    bool fWritePriority/* = true*/,
    LONG nReadCount/* = LONG_MAX*/
)
{
    SECURITY_ATTRIBUTES sa = { 0 };
    SECURITY_DESCRIPTOR sd = { 0 };
    bool fResult = false;
    bool fCreate = false;

    sa.nLength = sizeof(sa);
    sa.bInheritHandle = FALSE;
    sa.lpSecurityDescriptor = &sd;

    _tstring strFileMapping = strName.empty() ? strName : strName + _T("_FileMapping");
    _tstring strReadSemaphore = strName.empty() ? strName : strName + _T("_ReadSemaphore");
    _tstring strShareMutex = strName.empty() ? strName : strName + _T("_ShareMutex");
    _tstring strWritableEvent = strName.empty() ? strName : strName + _T("_ReadEvent");
    _tstring strReadableEvent = strName.empty() ? strName : strName + _T("_WriteEvent");
    _tstring strWriteMutex = strName.empty() ? strName : strName + _T("_WriteMutex");

    Uninitialize();

    (void)::InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
    (void)::SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);

    do
    {
        // 创建访问互斥量
        m_hShareMutex = ::CreateMutex(
            &sa,
            FALSE,
            strShareMutex.empty() ? NULL : strShareMutex.c_str()
        );
        if (!m_hShareMutex)
        {
            break;
        }

        // 创建读取信号量
        m_hReadSemaphore = ::CreateSemaphore(
            &sa,
            nReadCount,
            nReadCount,
            strReadSemaphore.empty() ? NULL : strReadSemaphore.c_str()
        );
        if (!m_hReadSemaphore)
        {
            break;
        }

        // 创建可写手动事件
        m_hWritableEvent = ::CreateEvent(
            &sa,
            TRUE,
            TRUE,
            strWritableEvent.empty() ? NULL : strWritableEvent.c_str()
        );
        if (!m_hWritableEvent)
        {
            break;
        }

        // 创建可读手动事件
        m_hReadableEvent = ::CreateEvent(
            &sa,
            TRUE,
            TRUE,
            strReadableEvent.empty() ? NULL : strReadableEvent.c_str()
            );
        if (!m_hReadableEvent)
        {
            break;
        }

        // 创建写入互斥量
        m_hWriteMutex = ::CreateMutex(
            &sa,
            FALSE,
            strWriteMutex.empty() ? NULL : strWriteMutex.c_str()
        );
        if (!m_hWriteMutex)
        {
            break;
        }

        // 创建共享内存
        m_hFileMapping = ::CreateFileMapping(
            INVALID_HANDLE_VALUE,
            &sa,
            PAGE_READWRITE,
            0,
            sizeof(SHARE_DATA),
            strFileMapping.empty() ? NULL : strFileMapping.c_str()
        );
        if (nullptr == m_hFileMapping)
        {
            break;
        }

        if (ERROR_ALREADY_EXISTS != ::GetLastError())
        {
            fCreate = true;
        }

        m_pShareData = (PSHARE_DATA)::MapViewOfFile(
            m_hFileMapping,
            FILE_MAP_READ | FILE_MAP_WRITE,
            0,
            0,
            0
        );
        if (nullptr == m_pShareData)
        {
            break;
        }

        //首次创建, 设置信息
        if (fCreate)
        {
            ::WaitForSingleObject(m_hShareMutex, INFINITE);
            memset(m_pShareData, 0, sizeof(SHARE_DATA));
            ::ReleaseMutex(m_hShareMutex);
        }

        fResult = true;

    } while (false);

    if (!fResult)
    {
        Uninitialize();
    }

    m_fWritePriority = fWritePriority;
    m_fInit = true;
    return fResult;
}

void CRWLockIPC::Uninitialize()
{
    if (m_hReadSemaphore)
    {
        ::CloseHandle(m_hReadSemaphore);
        m_hReadSemaphore = nullptr;
    }

    if (m_hWriteMutex)
    {
        ::CloseHandle(m_hWriteMutex);
        m_hWriteMutex = nullptr;
    }

    if (m_hWritableEvent)
    {
        ::SetEvent(m_hWritableEvent);
        ::CloseHandle(m_hWritableEvent);
        m_hWritableEvent = nullptr;
    }

    if (m_hReadableEvent)
    {
        ::SetEvent(m_hReadableEvent);
        ::CloseHandle(m_hReadableEvent);
        m_hReadableEvent = nullptr;
    }

    if (m_hShareMutex)
    {
        DWORD dwWait = ::WaitForSingleObject(m_hShareMutex, INFINITE);
        if (WAIT_OBJECT_0 == dwWait)
        {
            if (m_pShareData)
            {
                ::UnmapViewOfFile(m_pShareData);
                m_pShareData = nullptr;
            }

            if (m_hFileMapping)
            {
                ::CloseHandle(m_hFileMapping);
                m_hFileMapping = nullptr;
            }
        }
        ::ReleaseMutex(m_hShareMutex);
        ::CloseHandle(m_hShareMutex);
        m_hShareMutex = nullptr;
    }

    m_fInit = false;
}

bool CRWLockIPC::AcquireReadLock(DWORD dwTimeout/* = INFINITE*/)
{
    bool fResult = false;
    bool fAbort = false;

    if (!m_fInit)
    {
        return false;
    }

    // 递增读等待计数
    {
        ::WaitForSingleObject(m_hShareMutex, INFINITE);
        m_pShareData->nReadWaitCount++;

        // 写操作优先: 若存在写操作等待，则阻止新的读操作获取锁
        if (m_fWritePriority && m_pShareData->nWriteWaitCount > 0)
        {
            ::ResetEvent(m_hReadableEvent);
        }

        ::ReleaseMutex(m_hShareMutex);
    }

    // 请求读锁
    do
    {
        // 等待可读事件有信号(无写操作时有信号)
        if (WAIT_OBJECT_0 != WaitForSingleObject(m_hReadableEvent, dwTimeout))
        {
            fAbort = true;
            break;
        }

        // 等待读信号量
        if (WAIT_OBJECT_0 != ::WaitForSingleObject(m_hReadSemaphore, dwTimeout))
        {
            fAbort = true;
            break;
        }

    } while (false);

    // 递减读等待计数
    {
        ::WaitForSingleObject(m_hShareMutex, INFINITE);
        m_pShareData->nReadWaitCount--;
        ::ReleaseMutex(m_hShareMutex);
    }

    if (!fAbort)
    {
        // 更新计数
        ::WaitForSingleObject(m_hShareMutex, INFINITE);

        // 读计数递增
        if (m_pShareData->nReadCount < LONG_MAX)
        {
            m_pShareData->nReadCount++;
        }

        // 设置可写事件无信号, 阻止写操作
        ::ResetEvent(m_hWritableEvent);
        ::ReleaseMutex(m_hShareMutex);

        fResult = true;

    } while (false);

    return fResult;
}

void CRWLockIPC::ReleaseReadLock()
{
    if (!m_fInit)
    {
        return;
    }

    // 释放读锁
    ::ReleaseSemaphore(m_hReadSemaphore, 1, NULL);

    // 计数检查
    {
        ::WaitForSingleObject(m_hShareMutex, INFINITE);

        // 更新读取计数
        if (m_pShareData->nReadCount > 0)
        {
            m_pShareData->nReadCount--;
        }

        // 没有任何读操作存在则允许写操作
        if (0 == m_pShareData->nReadCount)
        {
            // 设置可写事件有信号, 允许写操作
            ::SetEvent(m_hWritableEvent);
        }

        ::ReleaseMutex(m_hShareMutex);
    }
}

bool CRWLockIPC::AcquireWriteLock(DWORD dwTimeout/* = INFINITE*/)
{
    bool fResult = false;

    if (!m_fInit)
    {
        return false;
    }

    // 递增写入等待数
    {
        ::WaitForSingleObject(m_hShareMutex, INFINITE);
        m_pShareData->nWriteWaitCount++;
        ::ReleaseMutex(m_hShareMutex);
    }

    // 获取写锁
    do
    {
        // 等待可写事件
        if (WAIT_OBJECT_0 != ::WaitForSingleObject(m_hWritableEvent, dwTimeout))
        {
            break;
        }

        // 等待写入互斥量事件
        if (WAIT_OBJECT_0 != ::WaitForSingleObject(m_hWriteMutex, dwTimeout))
        {
            break;
        }

        fResult = true;

    } while (false);

    // 递减写入等待数
    {
        ::WaitForSingleObject(m_hShareMutex, INFINITE);
        m_pShareData->nWriteWaitCount--;
        ::ReleaseMutex(m_hShareMutex);
    }

    // 获取锁成功则递增写计数, 并且重置可读事件设为无信号, 防止读线程读取
    if (fResult)
    {
        ::WaitForSingleObject(m_hShareMutex, INFINITE);

        // 更新写计数
        if (m_pShareData->nWriteCount < LONG_MAX)
        {
            m_pShareData->nWriteCount++;
        }

        ::ResetEvent(m_hReadableEvent);
        ::ReleaseMutex(m_hShareMutex);
    }

    return fResult;
}

void CRWLockIPC::ReleaseWriteLock()
{
    if (!m_fInit)
    {
        return;
    }

    // 释放写锁
    ::ReleaseMutex(m_hWriteMutex);

    // 递减写计数
    {
        ::WaitForSingleObject(m_hShareMutex, INFINITE);

        // 更新写计数
        if (m_pShareData->nWriteCount > 0)
        {
            m_pShareData->nWriteCount--;
        }

        // 不存在写等待则设置可读事件为有信号
        if (0 == m_pShareData->nWriteWaitCount)
        {
            ::SetEvent(m_hReadableEvent);
        }

        ::ReleaseMutex(m_hShareMutex);
    }
}

main.cpp

#include <locale.h>
#include <tchar.h>
#include <time.h>
#include "Win32Utils/CStrUtils.h"
#include "Win32Utils/CRWLockIPC.h"
#include <thread>
#include <vector>
#include <mutex>

std::mutex mutex;
void CReadWriteLockTest(CRWLockIPC& rwLock, int read, int write)
{
    std::vector<std::thread> vTasks;

    auto cbRead = [&rwLock](int i) {
        mutex.lock();
        CStrUtils::ConsoleOutput(_T("read start: %d\n"), i);
        mutex.unlock();
        rwLock.AcquireReadLock();
        mutex.lock();
        CStrUtils::ConsoleOutput(_T("read data: %d\n"), i);
        mutex.unlock();
        rwLock.ReleaseReadLock();
        };

    auto cbWrite = [&rwLock](int i) {
        mutex.lock();
        CStrUtils::ConsoleOutput(_T("write start: %d\n"), i);
        mutex.unlock();
        rwLock.AcquireWriteLock();
        mutex.lock();
        CStrUtils::ConsoleOutput(_T("write data: %d\n"), i);
        mutex.unlock();
        rwLock.ReleaseWriteLock();
        };

    for (int i = 0; i < read; i++)
    {
        vTasks.emplace_back(std::thread(cbRead, i));
    }

    for (int i = 0; i < write; i++)
    {
        vTasks.emplace_back(std::thread(cbWrite, i));
    }

    for (auto& item : vTasks)
    {
        if (item.joinable())
        {
            item.join();
        }
    }
}

int ReadTest(CRWLockIPC& rwLock)
{
    CHAR ch = 0;
    while (true)
    {
        CStrUtils::ConsoleOutput(_T("按任意键获取读锁\n"));
        ch = ::getchar();
        CStrUtils::ConsoleOutput(_T("正在获取读锁...\n"));
        bool fResult = rwLock.AcquireReadLock();
        CStrUtils::ConsoleOutput(_T("已获取读锁, 按任意键释放读锁\n"));
        ch = ::getchar();
        rwLock.ReleaseReadLock();

        if (ch == 'q')
        {
            return 0;
        }
    }

    return 0;
}

int WriteTest(CRWLockIPC& rwLock)
{
    CHAR ch = 0;
    while (true)
    {
        CStrUtils::ConsoleOutput(_T("按任意键获取写锁\n"));
        ch = ::getchar();
        CStrUtils::ConsoleOutput(_T("正在获取写锁...\n"));
        bool fResult = rwLock.AcquireWriteLock();
        CStrUtils::ConsoleOutput(_T("已获取写锁, 按任意键释放写锁\n"));
        ch = ::getchar();
        rwLock.ReleaseWriteLock();

        if (ch == 'q')
        {
            return 0;
        }
    }

    return 0;
}

int _tmain(int argc, LPCTSTR argv[])
{
    setlocale(LC_ALL, "");

    CRWLockIPC rwLock;
    rwLock.Initialize(_T("CReadWriteLock"), true);

    while (true)
    {
        system("cls");
        CReadWriteLockTest(rwLock, 32, 32);
        CStrUtils::ConsoleOutput(_T("按任意键继续\n"));
        CHAR ch = ::getchar();
        if (ch == 'q')
        {
            return 0;
        }
    }

    return 0;
}

《C/C++实战专栏》介绍
dvlinker的技术专栏
07-31 15万+
本文详细介绍《C/C++实战专栏》的主体内容构成。
C/C++学习路线总结与分享
热门推荐
dvlinker的技术专栏
10-07 10万+
C/C++学习路线总结与分享
PLock-简单高效的跨进程锁，支持读写锁分离.zip
09-24
简单高效的跨进程锁，支持读写锁分离,  也可以用于文件锁Getting startedIn your build.gradle:allprojects {     repositories {         maven { url 'https://jitpack.io' }     } } dependencies {     implementation 'com.github.pqpo:PLock:{last-version}'}UsageStep 1. get a default PLock object, and you can also create one by yourself.Step 2. acquire locks.Step 3. unlock.Step 4. release if necessary.For example:PLock pLock = PLock.getDefault();// OR you can also use it as a file lock:// PLock pLock = new PLock(file);pLock.lock();  try {    // to do something...} catch (Exception e) {    // errors} finally {     pLock.unlock();  }// in non-blocking modeif(pLock.tryLock()) {   try {       // to do something...    } catch (Exception e) {       // errors    } finally {        pLock.unlock();     } }  // non-block read lockif(pLock.tryReadLock()) {    // to do something...}  // non-block write lockif(pLock.tryWriteLock()) {    // to do something...}  // etc.// pLock.release();Play with samples, have fun!You can clone this repository, then run 'debug' build variant and 'second' build variant, after that you can see two applications running on your phone which named PLock-FirstProcess and PLock-SecondProcess.Or download PLock-FirstProcess and PLock-SecondProcess.PLock-first-processPLock-second-process
【Linux 应用开发 】Linux 跨进程读写锁全解析：原理、实现与实践
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-03 1490
读写锁（Read-Write Locks）是一种同步机制，用于控制对共享资源的访问。在我们探索这个概念之前，不妨思考一下人类在团队工作中的协作方式。正如一个团队中的成员可能需要等待其他成员完成他们的任务才能继续自己的工作一样，多个进程或线程在访问共享资源时也需要相互协调和等待。
Windows系统中的互斥进程锁（Mutex）详解与应用
最新发布
weixin_36303807的博客
05-29 819
在多线程编程中，同步机制是确保数据一致性和线程安全的关键技术之一。互斥量（Mutex）是众多同步机制中的一种，它用于控制多个线程对共享资源的互斥访问。互斥量能够保证在任何时刻，只有一个线程能够访问到共享资源，从而避免了竞态条件的发生。在本章中，我们将介绍互斥量的基本概念，并探讨其在同步对象家族中的角色。我们将分析互斥量的工作原理，并说明它如何通过简单的所有权机制来实现线程间的同步。
aardio - 【库】lock 跨进程读写锁
光庆的学习笔记
06-22 571
【代码】aardio - 【库】lock 跨进程读写锁。
多进程编程——记录锁
xingg的C++世界
09-09 5082
多进程编程的核心技术是进程间的同步——通信与互斥访问 一、进程间的通信 1、管道 2、System V信号量 3、共享内存 4、消息队列 5、信号  6、套接字 二、进程间对资源的互斥访问 条件变量 信号量 读写锁（记录锁） 自旋锁 原子锁（顺序
进程间通信学习笔记-互斥锁 && 读写锁
zz460833359的博客
09-17 248
第七章 互斥锁和条件变量 互斥锁是用于保护临界区的，实际上是保护在临界区中被操纵的数据，保护多个线程或者多个进程的共享数据。 #include<pthread.h> int pthread_mutex_lock(pthread_mutex_t *mptr); int pthread_mutex_trylock(pthread_mutex_t *mptr); int pthread_mutex_unlock(pthread_mutex_t *mptr); 如果互斥锁已被其他线程占据了，那么pth
跨平台读写锁
JUST_DO_1122的博客
01-18 339
class CMyRWLock { public: CMyRWLock(); ~CMyRWLock(); void readLock(); bool tryReadLock(); void writeLock(); bool tryWriteLock(); void unlock(); private: #ifdef _WIN32 void addWriter(); void removeWriter(); unsigned long tryReadLockOnce(); HA.
WINDOWS读写锁的简单实现
Mr_SGQ的专栏
04-26 2732
//最近看到了非常好的一篇WINDOWS读写锁的代码，无论类的设计上还是锁的逻辑实现上都很不错。。。     RWLockImpl.h 01.#ifndef _RWLockImpl_Header 02.#define _RWLockImpl_Header 03. 08. 09.using namespace std; 10. 11./* 12. 读写锁允许当前的多个读用户访问
c++的跨平台的读写锁的实现
陈嘉怡的专栏
04-10 2817
使用宏区分win和linux下的锁的实现。 头文件 RWLock.h ////////////////////////////////////////////////////////////////////////// //读写锁 ////////////////////////////////////////////////////////////////////////// #i...
windows读写锁
11-17
在网上看到很多读写锁,经过测试都有一些问题,现在我用临界区域的原理,做了一个读写锁功能,适合windows平台,附件中是锁的类,和测试代码
windows下的进程锁
08-28
windows系统下互斥进程锁mutex
windows 读写锁 （基于关键区的读写锁类 及自动锁）
04-26
读写锁的类 及demo 基于网上的类 改写了几处逻辑不合理的地方 ：1、新的读锁来了如已有写锁等待 新的读锁进入等待 2、等待的读锁获取到执行权限后 把正等待的所有读锁全部激活
Windows下实现的读写锁（VS2008环境）
10-11
WIN环境下实现的轻量级读写锁，效率还过得去，C++代码使用Interlocked系列函数实现。
C++x64内核保护进程源码_保护进程_x64内核保护进程_进程保护_进程保护c++
08-09
在C++中，可以使用Windows API函数（如CreateToolhelp32Snapshot）来遍历和分析进程，或者编写内核驱动程序来获取更高的控制权限。 5. **源码分析**：`ProtectProcess`可能是源码中的关键函数或类，负责实现进程...
C/C++ 性能优化思路
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
03-09 913
C/C++ 性能优化
win32 读写锁
xinlu0311的专栏
12-23 547
#define _RW_LOCK_h_#include "stdint.h"#include #include #define RWLOCK_FREE   0#define RWLOCK_LOCKED  1class CRWLock{public: inline CRWLock(void):m_ulRLock(0),m_ulWLock(0),m_ulPreLock(0){}; void
Win32 实现读写锁
Emacs的专栏
03-04 2478
Win32中没有为Xp提供读写锁机制（只为Vista提供了）， 由于工作需求，所以自己实现了一个简单的读写锁，具体实现如下：头文件：rwlocker.h#ifndef _RWLOCKER_H_#define _RWLOCKER_H_#include namespace Locker{ class RWLocker { private: unsigned l
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值