读写锁总结

最新推荐文章于 2022-05-11 08:00:00 发布
最新推荐文章于 2022-05-11 08:00:00 发布
阅读量301 收藏
点赞数 1
分类专栏： 常用代码 文章标签： 读写锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tifentan/article/details/78951127
版权

参看我前一篇文章：http://blog.csdn.net/tifentan/article/details/78949028

这里再提供一个跨平台的简单实现：

//完成读写锁初始化
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);
    if (m_RWLock.hDataLock == NULL)
    {
        return FALSE;
    }

    m_RWLock.hMutex = CreateMutex(NULL, FALSE, NULL);
    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)
    {
        return FALSE;
    }

    m_RWLock.nReaderCount ++;
    if(m_RWLock.nReaderCount == 1)
    {
        result = MyWaitForSingleObject(m_RWLock.hDataLock);
    }

    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)
    {
        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);

#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
}

然而这个是有问题的，多个读线程高频率读，写锁有可能进入不了。
解决方法是再建立一个mutex来管理资源状态，确认有更新数据才进入读锁。

关于读写的优先问题

以下两种情况下读写请求会进行竞争：
1.释放写锁后
2.在读锁状态下，有写锁请求会等待，之后再有新的读锁请求将一同等待，当读锁状态释放后

会不会同时有读写锁请求的情况下，优先写锁会好点呢？
上篇文章是公平竞争的，如果要求写优先，可参考https://www.cnblogs.com/kuliuheng/p/4065304.html的linux部分，关键在于使用到一个状态锁，两个条件事件。
修改后代码如下：

//写优先读写锁
class RWLockAdv
{
private:
    int _st;
    int _rlockCount;
    int _rwaitingCount;
    int _wwaitingCount;
    HANDLE _wev;
    HANDLE _rev;
#ifdef CROSS_PROCESS_IPC
    HANDLE _stLock;
#else
    CRITICAL_SECTION _stLock;
#endif

public:
    RWLockAdv(void);
    ~RWLockAdv(void);
    void rlock();
    void wlock();
    void unlock();
};

#define RWLOCK_IDLE 0    
#define RWLOCK_R 0x01    
#define RWLOCK_W 0x02    



RWLockAdv::RWLockAdv(void)
    : _rlockCount(0),
    _st(RWLOCK_IDLE),
    _rwaitingCount(0),
    _wwaitingCount(0)
{
#ifdef CROSS_PROCESS_IPC
    _stLock = CreateMutex(NULL, FALSE, NULL);
    assert(_stLock != INVALID_HANDLE_VALUE);
#else
    InitializeCriticalSection(&_stLock);
#endif

    _wev = CreateEvent(NULL, TRUE, FALSE, NULL);
    assert(_wev != INVALID_HANDLE_VALUE);
    _rev = CreateEvent(NULL, TRUE, FALSE, NULL);
    assert(_rev != INVALID_HANDLE_VALUE);
}


RWLockAdv::~RWLockAdv(void)
{
#ifdef CROSS_PROCESS_IPC
    CloseHandle(_stLock);
#else
    DeleteCriticalSection(&_stLock);
#endif
    CloseHandle(_wev);
    CloseHandle(_rev);
}

void RWLockAdv::rlock()
{
    bool isWaitReturn = false;
    while (1)
    {
#ifdef CROSS_PROCESS_IPC
        WaitForSingleObject(_stLock, INFINITE);
#else
        EnterCriticalSection(&_stLock);
#endif
        if (isWaitReturn)
        {

            --_rwaitingCount;
        }

        if (_st == RWLOCK_IDLE)
        {

            _st = RWLOCK_R;
            _rlockCount++;
#ifdef CROSS_PROCESS_IPC
            ReleaseMutex(_stLock);
#else
            LeaveCriticalSection(&_stLock);
#endif
            break;
        }
        else if (_st == RWLOCK_R)
        {
            if (_wwaitingCount > 0)
            {

                ++_rwaitingCount;
                ResetEvent(_rev);

#ifdef CROSS_PROCESS_IPC
                SignalObjectAndWait(_stLock, _rev, INFINITE, FALSE);
#else
                LeaveCriticalSection(&_stLock);
                WaitForSingleObject(_rev, INFINITE);
#endif
                isWaitReturn = true;
            }
            else
            {

                ++_rlockCount;

#ifdef CROSS_PROCESS_IPC
                ReleaseMutex(_stLock);
#else
                LeaveCriticalSection(&_stLock);
#endif
                break;
            }
        }
        else if (_st == RWLOCK_W)
        {

            ++_rwaitingCount;
            ResetEvent(_rev);

#ifdef CROSS_PROCESS_IPC
            SignalObjectAndWait(_stLock, _rev, INFINITE, FALSE);
#else
            LeaveCriticalSection(&_stLock);
            WaitForSingleObject(_rev, INFINITE);
#endif

            isWaitReturn = true;
        }
        else
        {
            assert(0);
            break;
        }
    }
}

void RWLockAdv::wlock()
{
    bool isWaitReturn = false;

    while (1)
    {
#ifdef CROSS_PROCESS_IPC
        WaitForSingleObject(_stLock, INFINITE);
#else
        EnterCriticalSection(&_stLock);
#endif

        if (isWaitReturn) --_wwaitingCount;

        if (_st == RWLOCK_IDLE)
        {
            _st = RWLOCK_W;

#ifdef CROSS_PROCESS_IPC
            ReleaseMutex(_stLock);
#else
            LeaveCriticalSection(&_stLock);
#endif
            break;
        }
        else
        {
            ++_wwaitingCount;
            ResetEvent(_wev);
#ifdef CROSS_PROCESS_IPC
            SignalObjectAndWait(_stLock, _wev, INFINITE, FALSE);
#else
            LeaveCriticalSection(&_stLock);
            WaitForSingleObject(_wev, INFINITE);
#endif


            isWaitReturn = true;
        }
    }
}

void RWLockAdv::unlock()
{
#ifdef CROSS_PROCESS_IPC
    WaitForSingleObject(_stLock, INFINITE);
#else
    EnterCriticalSection(&_stLock);
#endif
    //这代表在读状态
    if (_rlockCount > 0)
    {

        --_rlockCount;

        if (0 == _rlockCount)
        {
            _st = RWLOCK_IDLE;

            if (_wwaitingCount > 0) {
                SetEvent(_wev);
            }
            else if(_rwaitingCount > 0){
                SetEvent(_rev);
            }
            else
            {

            }
        }
        else
        {

        }
    }
    else
    {
        _st = RWLOCK_IDLE;


        //也可以改成写状态释放后优先读？
        if (_wwaitingCount > 0) {
            SetEvent(_wev);
        }
        else if (_rwaitingCount > 0) {
            SetEvent(_rev);
        }
        else
        {

        }
    }
#ifdef CROSS_PROCESS_IPC
    ReleaseMutex(_stLock);
#else
    LeaveCriticalSection(&_stLock);
#endif
}

代码没测试，待续！！！

露蛇
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
读写锁
小神仙的博客
07-02 768
读写锁 读写锁的概念 Pthread是 POSIX threads 的简称，是POSIX的线程标准。 pthread读写锁把对共享资源的访问者分为读者和写者，读者只对共享资源进行读访问，写者只对共享资源进行写操作。在互斥机制，读者和写者都需要独立独占互斥量以独占共享资源，在读写锁机制下，允许同时有多个读者读访问共享资源，只有写者才需要独占资源。相比互斥机制，读写机制由于允许多个读者同时...
Linux多线程编程（四）-----读写锁
LLZK_的博客
02-27 1237
概述读写锁类似于互斥锁（互斥量），不过读写锁允许更高的并行性，主要体现在读者方面。这种锁有利于读的机会多，写的机会少的共享数据。它可分为以下两种情况： 写者竞争到锁资源。在写者加锁，正在写的情况下，所有试图竞争这个锁的读者写者线程都会被阻塞。 读者竞争到锁资源。在读写加锁，正在读的情况下，为了体现并行性，当有新读者试图读取并且申请加锁的时候，将被允许。也就是说，一块共享数据可以同时被多个读者读取。但
读写锁实现例子
08-14
总结起来，这个例子展示了如何使用读写锁来实现线程安全的共享资源访问。通过使用读写锁，我们可以优化多线程程序的性能，尤其是在读操作远多于写操作的场景下。在实际应用中，可以根据系统的需求调整读锁的最大数量...
Java的两种读写锁介绍
11-18
总结，Java中的读写锁为并发编程提供了强大的工具，可以根据具体需求选择合适的锁类型。ReentrantReadWriteLock适合大多数情况，而StampedLock则更适合高并发、对锁有更高级需求的场景。理解并正确使用这些锁机制，...
C#使用读写锁三行代码简单解决多线程并发的问题
09-01
为了解决这个问题，我们可以利用C#中的读写锁（ReaderWriterLockSlim）来实现线程同步。本文通过三行代码展示了如何使用读写锁解决多线程并发写入文件的冲突。 读写锁的核心在于，它允许多个线程同时读取资源，但只...
面试官：有没有比读写锁更快的锁？
12-21
总结：面试中，面试官询问是否有比读写锁更快的锁，小明提到了读写锁在读多写少的情况下的优势，但面试官进一步提出了StampedLock。StampedLock通过悲观读、写锁和乐观读模式，提供了一种更高级别的并发控制，特别是...
易语言线程安全之原子锁与读写锁
06-05
总结来说，线程安全是多线程编程的基础，而原子操作和读写锁是实现线程安全的重要工具。易语言提供了丰富的支持，使得开发者能够方便地在自己的程序中实现线程安全，从而构建高效且稳定的多线程应用程序。通过合理...
锁—读写锁
chengcheng1024的博客
11-12 255
1、概述 读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态，要么是不加锁状态，而且一次只有一个线程对其加锁。读写锁可以有三种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可用同时占有读模式的读写锁。读写锁也叫做共享-独占锁，当读写锁以读模式锁住时，它是以共享模式锁住的，当它以写模式锁住时，它是以独占模式锁住的。 2、读写锁API 读写锁的数据类型为pthread_rwlock_t。如果这个类型的某个变量是静态分配的，那么可通过给
数据库系统概念-读写锁、意向锁、行表锁
m0_37965811的博客
05-29 756
1、按照几种不同的分类方式，MySql中的几种锁可以分为读写锁、意向锁、行表锁 按照锁粒度分类：表锁和行锁，即这这个锁是锁住整张表还是表中的某几行
读写锁 ReadWriteLock 获取锁有哪些规则？
a904364908的博客
08-14 298
在没有读写锁之前，我们假设使用普通的 ReentrantLock，那么虽然我们保证了线程安全，但是也浪费了一定的资源，因为如果多个读操作同时进行，其实并没有线程安全问题，我们可以允许让多个读操作并行，以便提高程序效率。 但是写操作不是线程安全的，如果多个线程同时写，或者在写的同时进行读操作，便会造成线程安全问题。 我们的读写锁就解决了这样的问题，它设定了一套规则，既可以保证多个线程同时读的效率，同时又可以保证有写入操作时的线程安全。 整体思路是它有两把锁，第 1 把锁是写锁，获得写锁之后，既可以读数据又可以
Java中常见的锁-----＞读写锁
NotRepent的博客
04-20 3602
独占锁 指该锁一次只能被一个线程所持有对于ReentrantLock和synchronized而言都是独占锁 共享锁 指该锁可以被多个线程所持有 对ReentrantReadWriteLock而言其读锁是共享锁，读锁是独占锁 读锁共享锁可保证并发读是非常高效的，其中读写，写读，写写是互斥的 ...
读写锁是什么
jigetage的专栏
02-12 1534
前言： 对于非计算机专业出身的朋友来说，很少会接触到读写锁这个高级概念，一般都只是使用到互斥量这一层。那么为什么有了互斥量（互斥锁）之后，还要发明读写锁呢？ 结论： 读写锁是效率更高的互斥量（在大多数条件下）。 理由： 读写锁分为三种状态 1，以读的方式占据锁的状态。此时，如果有另外线程请求以读的方式占据锁，那么不会阻塞，可以再次占据。如果有另外线程请求以写的方式占据锁，那么会阻塞，直...
读写锁的理解
weixin_42988712的博客
09-15 273
读《java多线程编程核心技术》做笔记 文章目录读写锁1.ReentrantLock类的缺点2.ReentrantReadWriteLock类的使用1.ReentrantReadWriteLock类的使用--读读共享2.ReentrantReadWriteLock类的使用--写写互斥3.ReentrantReadWriteLock类的使用--读写互斥4.ReentrantReadWriteLock类的使用--写读互斥 验证代码链接： 百度 改为 baidu 链接：https://pan.
读写锁的原理
Laiyer_的博客
03-22 875
1.为什么需要读写锁,它和ReentrantLock有什么区别？ 如果读取的数据和写的数据没有关联，可以直接无锁+重入锁；但是一旦读取的数据和写的数据有重叠。那么读的数据可能出现不一致（可以对比数据库），所以此时要求读的时候不能写，写的时候不能读，读和读不冲突； 2.实现原理 读写锁简单来说就是一把读锁和写锁，写锁就是reentrantlock没有啥区别；所以值关注一下读锁就可以了。 /** * The number of reentrant read locks held by cu
Linux线程同步 读写锁 rwlock
jie310600的博客
08-17 149
读写锁比mutex有更高的适用性，可以多个线程同时占用读模式的读写锁，但是只能一个线程占用写模式的读写锁。 1. 当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞； 2. 当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是以写模式对它进行枷锁的线程将阻塞； 3. 当读写锁在读模式锁状态时，如果有另外线程试图以写模式加锁，读写锁...
一文详解读写锁
热门推荐
磊哥聊Java
05-11 1万+
作者 | 磊哥来源 | Java面试真题解析（ID：aimianshi666）转载请联系授权（微信ID：GG_Stone）读写锁（Readers-Writer Lock）顾名思义是一把锁分为两部分：读锁和写锁，其中读锁允许多个线程同时获得，因为读操作本身是线程安全的，而写锁则是互斥锁，不允许多个线程同时获得写锁，并且写操作和读操作也是互斥的。总结来说，读写锁的特点是：读读...
redission读写锁
最新发布
09-05
Redisson提供了读写锁的功能。读写锁在并发场景中非常有用，特别是对于读操作远多于写操作的情况。读写锁允许多个线程同时持有读锁，但只允许一个线程持有写锁。 通过使用Redisson的读写锁，你可以实现对某个关键字进行并发的读和写操作控制。当一个线程持有读锁时，其他线程也可以持有读锁，但是当有线程持有写锁时，其他的写锁和读锁都会被阻塞。 在实际应用中，如果有一个场景需要并发读取数据，然后并发进行扣减操作，可能会出现扣减失败的情况。这是因为在读取的时候还有库存，但是在扣减的时候库存已经没有了。为了避免这种情况，可以使用Redisson的读写锁来保证并发读写的线程安全性。 在使用Redisson的读写锁时，可以通过以下方式进行操作： - 使用`readLock()`方法获取读锁，并通过`lock()`方法加锁，然后使用`unlock()`方法释放读锁。 - 使用`writeLock()`方法获取写锁，并通过`lock()`方法加锁，然后使用`unlock()`方法释放写锁。 在你的代码示例中，可以看到使用Redisson的读写锁的具体操作。通过`getReadWriteLock(key)`方法获取读写锁，然后使用`readLock()`方法获取读锁或使用`writeLock()`方法获取写锁。最后使用`lock()`方法加锁，使用`unlock()`方法释放锁。 总结起来，Redisson的读写锁提供了一种并发控制机制，可以在并发读写场景下确保数据的一致性与线程安全性。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [redission读写锁解决db和缓存双写不一致](https://blog.csdn.net/weixin_43944305/article/details/120191365)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值