Windows核心编程笔记（八）用户模式下的线程同步 SRWLock剖析

最新推荐文章于 2021-11-23 23:02:03 发布
最新推荐文章于 2021-11-23 23:02:03 发布
阅读量5.5k 收藏 7
点赞数 2
分类专栏： Windows核心编程 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangpengk7788/article/details/54374680
版权

在VISTA及之后的系统中，引入了 SRWLock 用户用户模式的线程同步，MSDN中是这样描述的。




SRWLock  轻量级的读写锁，它与临界区对象的不同在于，它分为两个模式来访问共享资源。并假设有两种类型的线程同时工作，一种用在读取共享资源，通常又称为消费线程，另一种用来对共享的资源进程写入操作，通常又称为生产线程。


共享模式下每个读取线程可以读取共享的数据，不受任何限制，它们可以同时读取共享数据。


独占模式下只运行一个写入线程访问共享数据，其他读/写线程都会被堵塞。 直到该线程释放了读写锁。


在多线程的情况下，生产线程和消费线程是无序的，SRWLock是一个指针，它的优势在于可以快速的更新锁的状态，劣势在这个指针可以存放有限的信息，因此SRWLock不能够递归获取，此外一个线程处于共享模式的时候，不能讲自身升级为独占模式。



初始化读写锁很简单

VOID WINAPI InitializeSRWLock(  PSRWLOCK SRWLock);
在Winbase.h文件中 

typedef RTL_SRWLOCK SRWLOCK, *PSRWLOCK;
typedef struct _RTL_SRWLOCK {
  PVOID Ptr;
} RTL_SRWLOCK, *PRTL_SRWLOCK;


可见读写锁确实只是一个指针变量。


使用读写锁：


在消费线程中

AcquireSRWLockShared

*******读取操作

ReleaseSRWLockShared



在生产线程中

AcquireSRWLockExclusive

*******写操作

ReleaseSRWLockExclusive




这个读写锁和关键段一样方便使用，作者经过测试发现读写锁的性能较关键有很大的提升，这是因为读写锁是基于原子访问的，关键段是基于事件内核对象的，从用户模式到内核模式的切换占用了大量的时钟周期。



剖析SRWLock,以React OS下对读写锁的实现代码来看其工作原理。


在实现中SRWLock 的这个指针变量是这样来标识信息的





该指针的低4位被用于4个不同的标志，它们有其对应的宏定义


#define RTL_SRWLOCK_OWNED_BIT   0
#define RTL_SRWLOCK_CONTENDED_BIT   1
#define RTL_SRWLOCK_SHARED_BIT  2
#define RTL_SRWLOCK_CONTENTION_LOCK_BIT 3
#define RTL_SRWLOCK_OWNED   (1 << RTL_SRWLOCK_OWNED_BIT)                                     //0位为1 表示有线程正在读/写共享资源
#define RTL_SRWLOCK_CONTENDED   (1 << RTL_SRWLOCK_CONTENDED_BIT)                             //1位为1  表示一个或者多个生产线程在等待独占资源
#define RTL_SRWLOCK_SHARED  (1 << RTL_SRWLOCK_SHARED_BIT)                                    //2位为1  表示一个或者多个消费线程在等待读取资源
#define RTL_SRWLOCK_CONTENTION_LOCK (1 << RTL_SRWLOCK_CONTENTION_LOCK_BIT)                   //3位为1   标识有一个线程在获取WAITBLOCK结构指针
#define RTL_SRWLOCK_MASK    (RTL_SRWLOCK_OWNED | RTL_SRWLOCK_CONTENDED | \
                             RTL_SRWLOCK_SHARED | RTL_SRWLOCK_CONTENTION_LOCK)
#define RTL_SRWLOCK_BITS    4

SRWLock 的高28位是一个指针，为什么只有28位呢，是因为它要指向对象的对齐方式是16，即地址的最低4位都是0，比如都是这样的0x00124710,0x00124720,0x00124850,   当需要获取指针所指向的对象时，只要将低4位全部置0，就可以得到对象的地址。


SRWLock 在同时有一个以上线程读写资源的时候，它指向一个结构体链表。


在有其他线程在读/资源的时候，一个线程调用AcquireSRWLockExclusive或者AcquireSRWLockShared  时会将一个在栈上构建的结构体挂入SRWLock 所指向的链表，这样每个将要读/写资源的线程都会在栈上构建这么一个结构体，并将结构体挂入链表中。

该结构体是这样定义的


typedef struct _RTLP_SRWLOCK_WAITBLOCK
{

    LONG SharedCount; //有多少线程 在等待读取
    volatile struct _RTLP_SRWLOCK_WAITBLOCK *Last;    
    volatile struct _RTLP_SRWLOCK_WAITBLOCK *Next;   //链表节指针

    union
    {
        LONG Wake;                                   //非0表示可以被唤醒，0表示继续睡眠
        struct
        {
            PRTLP_SRWLOCK_SHARED_WAKE SharedWakeChain;   //需要被唤醒的消费线程链表
            PRTLP_SRWLOCK_SHARED_WAKE LastSharedWake;    //上一个被唤醒的消费线程
        };
    };
    BOOLEAN Exclusive;                         //1表示该结构体对象由生产线程构建在栈上，0表示结构体由消费线程构建在栈上
} volatile RTLP_SRWLOCK_WAITBLOCK, *PRTLP_SRWLOCK_WAITBLOCK;


下面是单向链表结构 ，代表每个需要被唤醒的消费线程 
typedef struct _RTLP_SRWLOCK_SHARED_WAKE
{
    LONG Wake;   //唤醒标志，非0唤醒，0睡眠
    volatile struct _RTLP_SRWLOCK_SHARED_WAKE *Next;
} volatile RTLP_SRWLOCK_SHARED_WAKE, *PRTLP_SRWLOCK_SHARED_WAKE;




初始化读写锁，只是简单的将指针置为0


NTAPI
RtlInitializeSRWLock(OUT PRTL_SRWLOCK SRWLock)
{
    SRWLock->Ptr = NULL;
}




AcquireSRWLockExclusive


它对应的函数是RtlAcquireSRWLockExclusive(IN OUT PRTL_SRWLOCK SRWLock)， 由于这个函数的代码比较长，这里先贴出大体结构，然后分部分注释。


NTAPI
RtlAcquireSRWLockExclusive(IN OUT PRTL_SRWLOCK SRWLock)
{
    __ALIGNED(16) RTLP_SRWLOCK_WAITBLOCK StackWaitBlock;    //构建于栈上的 对齐为16字节的 等待块
    PRTLP_SRWLOCK_WAITBLOCK First, Last;

    if (InterlockedBitTestAndSetPointer(&SRWLock->Ptr,
                                        RTL_SRWLOCK_OWNED_BIT))   //如果有其他线程在访问资源，进入循环，该原子访问函数返回之前的位值
    {
        LONG_PTR CurrentValue, NewValue;

        while (1)
        {
            CurrentValue = *(volatile LONG_PTR *)&SRWLock->Ptr;

            if (CurrentValue & RTL_SRWLOCK_SHARED)
            {
                    if (CurrentValue & RTL_SRWLOCK_CONTENDED)
                {
                    goto AddWaitBlock;
                }    
                else
                {
                }               //Part1, 如果有线程在读取资源，且没有其他生产线程在独占资源
            }
            else
            {
                if (CurrentValue & RTL_SRWLOCK_OWNED)
                {

                    if (CurrentValue & RTL_SRWLOCK_CONTENDED)
                    {
AddWaitBlock:
                                 //Part2,如果有其他线程在等待独占资源                    
                    }
                    else
                    {
				//Part3,如果有线程独占资源，且没有其他线程在等待资源
                    }
                }
                else
                {
                    if (!InterlockedBitTestAndSetPointer(&SRWLock->Ptr,
                                                         RTL_SRWLOCK_OWNED_BIT))
                    {
                        break;
                    }
                }
            }

            YieldProcessor();     执行空指令
        }
    }
}

最后一个函数  只是执行一个NOP指令，只是用来做延时而已，

    #define YieldProcessor() __asm__ __volatile__("nop");




Part1

                if (CurrentValue & RTL_SRWLOCK_CONTENDED)
                {
                    goto AddWaitBlock;
                }
                else
                {
                    StackWaitBlock.Exclusive = TRUE;                               //标识结构体位于生产线程的栈上
                    StackWaitBlock.SharedCount = (LONG)(CurrentValue >> RTL_SRWLOCK_BITS);  //目前的高28位标识多少个线程在等待读取
                    StackWaitBlock.Next = NULL;
                    StackWaitBlock.Last = &StackWaitBlock;
                    StackWaitBlock.Wake = 0;             //初始化这个栈上的结构体
                    NewValue = (ULONG_PTR)&StackWaitBlock | RTL_SRWLOCK_SHARED | RTL_SRWLOCK_CONTENDED | RTL_SRWLOCK_OWNED;//设置新指针为该栈上结构地址
																并设置标志位
                    if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                    (PVOID)NewValue,
                                                                    (PVOID)CurrentValue) == CurrentValue) 更换指针为新的值
                    {
                        RtlpAcquireSRWLockExclusiveWait(SRWLock,
                                                        &StackWaitBlock);    进入生产线程的等待函数
                        break;
                    }


看下这个生产线程的等待函数


NTAPI
RtlpAcquireSRWLockExclusiveWait(IN OUT PRTL_SRWLOCK SRWLock,
                                IN PRTLP_SRWLOCK_WAITBLOCK WaitBlock)
{
    LONG_PTR CurrentValue;

    while (1)
    {
        CurrentValue = *(volatile LONG_PTR *)&SRWLock->Ptr;
        if (!(CurrentValue & RTL_SRWLOCK_SHARED))
        {
            if (CurrentValue & RTL_SRWLOCK_CONTENDED)
            {
                if (WaitBlock->Wake != 0)
                {
                    break;
                }
            }
            else
            {
                break;
            }
        }

        YieldProcessor();                         //只有在没有线程在读取，没有其他生产线程在独占，或者独占的线程将该线程的WAKE标志设为非0，时退出死循环
    }
}

该函数保证了没个生产线程以独占的模式运行，其他生产线程只能在这里死循环，只要被唤醒，或者独占标志位被清除。



Part2:


AddWaitBlock:
                        StackWaitBlock.Exclusive = TRUE;
                        StackWaitBlock.SharedCount = 0;
                        StackWaitBlock.Next = NULL;
                        StackWaitBlock.Last = &StackWaitBlock;
                        StackWaitBlock.Wake = 0;                             初始化结构体

                        First = RtlpAcquireWaitBlockLock(SRWLock);           根据28位的指针去掉标志位，获取指向的链表表头，
                        if (First != NULL)
                        {
                            Last = First->Last;
                            Last->Next = &StackWaitBlock;
                            First->Last = &StackWaitBlock;           //将该线程栈上的结构体挂入链表的最后面，将表头的Last指向最后这个挂入的

                            RtlpReleaseWaitBlockLock(SRWLock);

                            RtlpAcquireSRWLockExclusiveWait(SRWLock,
                                                            &StackWaitBlock);  //进入等待循环

                            break;
                        }

RtlpAcquireWaitBlockLock  揭示了 如何通过28位的指针工作 


NTAPI
RtlpAcquireWaitBlockLock(IN OUT PRTL_SRWLOCK SRWLock)
{
    LONG_PTR PrevValue;
    PRTLP_SRWLOCK_WAITBLOCK WaitBlock;

    while (1)
    {
        PrevValue = InterlockedOrPointer(&SRWLock->Ptr,
                                         RTL_SRWLOCK_CONTENTION_LOCK); //低位 第3位如果是1表示，有其他线程在调用该函数根据指针获取链表头
										这里保证了 只有一个线程可以访问链表，其他需要访问的要等待
        if (!(PrevValue & RTL_SRWLOCK_CONTENTION_LOCK))
            break;

        YieldProcessor();
    }

    if (!(PrevValue & RTL_SRWLOCK_CONTENDED) ||
        (PrevValue & ~RTL_SRWLOCK_MASK) == 0)
    {
        RtlpReleaseWaitBlockLock(SRWLock);   //如果现在没有处于独占模式 或者 高28位 为0   ，错误 释放RTL_SRWLOCK_CONTENTION_LOCK标志位
        return NULL;
    }

    WaitBlock = (PRTLP_SRWLOCK_WAITBLOCK)(PrevValue & ~RTL_SRWLOCK_MASK);   将指针与0x11111110  与操作， 将低4位标志清除，构成实际地址

    return WaitBlock;
}


NTAPI
RtlpReleaseWaitBlockLock(IN OUT PRTL_SRWLOCK SRWLock)
{
    InterlockedAndPointer(&SRWLock->Ptr,
                          ~RTL_SRWLOCK_CONTENTION_LOCK);     只是简单将该标志位设为0
}


Part3:


                        StackWaitBlock.Exclusive = TRUE;
                        StackWaitBlock.SharedCount = 0;
                        StackWaitBlock.Next = NULL;
                        StackWaitBlock.Last = &StackWaitBlock;
                        StackWaitBlock.Wake = 0;  初始化结构体

                        NewValue = (ULONG_PTR)&StackWaitBlock | RTL_SRWLOCK_OWNED | RTL_SRWLOCK_CONTENDED;   将结构体地址构成新的指针
                        if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                        (PVOID)NewValue,
                                                                        (PVOID)CurrentValue) == CurrentValue)  替换原来的指针
                        {
                            RtlpAcquireSRWLockExclusiveWait(SRWLock,
                                                            &StackWaitBlock);   进入等待
                            break;
                        }


第一部分 和第三不分 代码差不多的，唯一的区别就是 第一不分多设置了一个标志位 RTL_SRWLOCK_SHARED，它们都是初始化栈上的结构体 并将结构体的地址加上标志位，然后替换为指针的值。


AcquireSRWLockExclusive  总结：


1、当有线程还在读取时，但是没有被其它生产线程独占， 那么挂入栈等待块，设置标志 （读取  独占 拥有），进入等待，读取线程全部Release时 线程等待结束，以独占模式访问资源

2、有其他生产线程在等待独占时，将栈块挂入SRWLock指针所指向链表的末尾，进入等待，在前面所有已挂入的等待都Release时，线程才结束等待 以独占模式访问资源。

3、如果有线程在独占，但是没有其他在等待独占的，那么挂入栈等待块，设置标志 （独占 拥有），进入等待，读取线程全部Release时 线程等待结束，以独占模式访问资源






ReleaseSRWLockExclusive


NTAPI
RtlReleaseSRWLockExclusive(IN OUT PRTL_SRWLOCK SRWLock)
{
    LONG_PTR CurrentValue, NewValue;
    PRTLP_SRWLOCK_WAITBLOCK WaitBlock;

    while (1)
    {
        CurrentValue = *(volatile LONG_PTR *)&SRWLock->Ptr;

        if (!(CurrentValue & RTL_SRWLOCK_OWNED))   //此时如果不处于拥有状态，抛出异常
        {
            RtlRaiseStatus(STATUS_RESOURCE_NOT_OWNED);
        }

        if (!(CurrentValue & RTL_SRWLOCK_SHARED))  //必须不处于读取状态
        {
            if (CurrentValue & RTL_SRWLOCK_CONTENDED) 
            {
                WaitBlock = RtlpAcquireWaitBlockLock(SRWLock);        
                if (WaitBlock != NULL)
                {
                    RtlpReleaseWaitBlockLockExclusive(SRWLock,
                                                      WaitBlock);           如果有等待独占的线程，调用该函数，将指针指向的链表头传给它

                    break;
                }
            }
            else
            {

                ASSERT(!(CurrentValue & ~RTL_SRWLOCK_OWNED));

                NewValue = 0;
                if ((LONG_PTR)InterlockedCompareExchangePointer(&SRWLock->Ptr,
                                                                (PVOID)NewValue,
                                                                (PVOID)CurrentValue) == CurrentValue)  //如果没有等待独占的，指针置为0
                {
                    break;
                }
            }
        }
        else
        {
            RtlRaiseStatus(STATUS_RESOURCE_NOT_OWNED);             如果处于读取状态 抛出异常
        }

        YieldProcessor();
    }
}



RtlpReleaseWaitBlockLockExclusive：


NTAPI
RtlpReleaseWaitBlockLockExclusive(IN OUT PRTL_SRWLOCK SRWLock,
                                  IN PRTLP_SRWLOCK_WAITBLOCK FirstWaitBlock)
{
    PRTLP_SRWLOCK_WAITBLOCK Next;
    LONG_PTR NewValue;


    Next = FirstWaitBlock->Next;
    if (Next != NULL)  如果还有其他在等待的线程
    {
        NewValue = (LONG_PTR)Next | RTL_SRWLOCK_OWNED | RTL_SRWLOCK_CONTENDED;
        if (!FirstWaitBlock->Exclusive)        如果第一个等待的线程是读取线程
        {
            ASSERT(Next->Exclusive);
            Next->SharedCount = FirstWaitBlock->SharedCount;  //复制读取线程计数

            NewValue |= RTL_SRWLOCK_SHARED;
        }

        Next->Last = FirstWaitBlock->Last;    将Last指向链尾的对象
    }
    else     //如果只有一个在等待的线程
    {
        if (FirstWaitBlock->Exclusive)  //如果该线程是生产线程，简单设置一个拥有位
            NewValue = RTL_SRWLOCK_OWNED;
        else
        {                           //如果该线程是消费线程，设置高位为线程计数，低位为标志 拥有  和  读取
            ASSERT(FirstWaitBlock->SharedCount > 0);

            NewValue = ((LONG_PTR)FirstWaitBlock->SharedCount << RTL_SRWLOCK_BITS) |
                       RTL_SRWLOCK_SHARED | RTL_SRWLOCK_OWNED;
        }
    }

    (void)InterlockedExchangePointer(&SRWLock->Ptr, (PVOID)NewValue);  设置新的指针

    if (FirstWaitBlock->Exclusive)
    {
        (void)InterlockedOr(&FirstWaitBlock->Wake,     将第一个等待的线程唤醒，如果它是生产线程的话。
                            TRUE);
    }
    else   //如果第一个等待唤醒的是一个消费线程的等待块，根据SharedWakeChain链表， 唤醒每一个等待的消费线程。
    {
        PRTLP_SRWLOCK_SHARED_WAKE WakeChain, NextWake;
        WakeChain = FirstWaitBlock->SharedWakeChain;
        do
        {
            NextWake = WakeChain->Next;

            (void)InterlockedOr((PLONG)&WakeChain->Wake,
                                TRUE);

            WakeChain = NextWake;
        } while (WakeChain != NULL);
    }
}




wangpengk7788
关注
专栏目录
《Windows核心编程》若干知识点实战应用分享
dvlinker的技术专栏
01-21 3万+
《Windows核心编程》若干知识点应用实践分享，希望大家能够仔细研读，在提升理论知识水平的同时，也能有效地提高分析解决问题的技能。
《Windows核心编程》读书笔记八 用户模式下的内核同步
sesiria的博客
09-30 2154
第八章 用户模式下的线程同步 本章内容 8.1 原子访问：Interlocked系列函数 8.2 高速缓存行 8.3 高级线程同步 8.4 关键段（临界区） 8.5 Slim 读/写锁 8.6 条件变量 什么是用户模式？ Windows系统上的CPU运行时有两种模式，User Mode 和 Kernel Mode（CPU硬件支持）详细参照MSDN https://
Windows线程同步—SRW锁
TechTiger的博客
03-23 1486
Windows线程同步—SRW锁     1.简介        临界区、互斥量保证临界资源只被一个线程访问，这里的访问包括读(read)和写(write)，如果读线程很频繁而写线程很少执行，这里就会造成CPU的浪费。因为仅仅读取资源的值并不存在破坏数据的风险，只有当写线程想要对资源进行更改时才需要同步。从而需要能对访问中的读和写进行分别对待的方法，SRW锁应运而生。SRW锁全称Slim
最新Windows下c++读写锁SRWLock介绍
chenzhjlf的专栏
12-22 8474
最新Windows下c++读写锁SRWLock介绍     本文导语:  读写锁在对资源进行保护的同时，还能区分想要读取资源值的线程（读取者线程）和想要更新资源的线程（写入者线程）。对于读取者线程，读写锁会允许他们并发的执行。当有写入者线程在占有资源时，读写锁会让...    读写锁在对资源进行保护的同时，还能区分想要读取资源值的线程（读取者线程）和想要更新
Windows线程同步之Slim读写锁（SRWLock）
jishublog
06-19 282
Slim读写锁简称SRWLock，它的目的和临界区相同，对一个资源进行保护，不让其他线程访问。但是不同的是SRWLock允许我们区分哪些线程是读取共享资源的值，哪些线程是修改共享资源的值。所有读线程在同一时刻可以访问共享资源，因为这些线程不会破坏共享资源，只有当写线程要访问共享资源时，才需要进行同步。写线程应当独占式访问资源，其他任何线程都不允许访问资源。这就是SRWLock提供的全部功能。 所...
秒杀多线程第十四篇 读者写者问题继 读写锁SRWLock
huobengluantiao8
06-13 277
在《秒杀多线程第十一篇读者写者问题》文章中我们使用事件和一个记录读者个数的变量来解决读者写者问题。问题虽然得到了解决，但代码有点复杂。本篇将介绍一种新方法——读写锁SRWLock来解决这一问题。读写锁在对资源进行保护的同时，还能区分想要读取资源值的线程（读取者线程）和想要更新资源的线程（写入者线程）。对于读取者线程，读写锁会允许他们并发的执行。当有写入者线程在占有资源时，读写锁会让其它写入者线程...
用RAII的思想去管理Windows的读写锁SRWLock
CodeBowl的博客
11-23 554
前言 最近对C++的RAII(资源申请初始化)，又有了新的理解。 我们C++中使用一个资源(例如 内存)的步骤： 申请资源 使用资源 释放资源 简述一下RAII： 就是可以自动回收资源，将资源封装成对象。 关键在于： 变量的生命周期结束后，会自动释放变量。 例如一个变量是局部变量，存储在栈上，那么当该函数结束后，这个变量就已经被释放掉了。 那么，当变量是类变量的时候，当该类对象变量生命周期结束后，应该调用析构函数释放掉该资源！ 生命周期 局部变量：存储在栈上，生命周期结束后，由栈释放。 全局或静态变量：
WINDOWS核心编程_笔记合集.zip
02-28
《WINDOWS核心编程》笔记合集是一份详尽深入的学习资源，涵盖了Windows操作系统内核编程的各个方面。这份资料可能包括了Windows API的底层实现、进程与线程管理、内存管理、I/O操作、设备驱动程序开发等多个关键主题...
Windows核心编程笔记（6）----用户模式下的线程同步
https://github.com/JelinYao
01-29 1319
1、原子锁 使用InterlockedExchangeAdd函数来实现原子增长，InterlockedExchange\InterlockedExchangePointer用来交换两个变 量的值，InterlockedCompareExchange对比数值，相等则交换（对应的InterlockedCompareExchangePointer）。对应的 还有64位函数。 Interlocke
windows核心编程读书笔记六.doc
07-07
《Windows核心编程》读书笔记六主要探讨了Windows操作系统内存管理和窗口消息处理的细节。以下是针对这两部分内容的关键知识点的详尽解析： ### 内存结构 1. **虚拟地址空间**：在32位Windows中，每个进程有4GB的...
windows核心编程-关键段与SRWLock
qq_22423659的博客
12-05 608
线程同步的方式主要有：临界区、互斥区、事件、信号量四种方式。 临界区线程同步也叫关键段线程同步 一、关键段 关键段(Critical Section)是一小段代码，它在执行之前需要独占一些共享资源的访问权。这里的原子方式是代码除了 当前线程之外，没有其他任何线程会同时访问该资源。当然系统仍然可以暂停当前线程去调度其他线程。但是在当 前线程离开关键段之前，系统是不会去调度任何想要访问统
线程堆栈的理解
rongwenbin的专栏
02-17 1142
一个线程的开销包括：       内核模式下的开销（内核堆栈，对象管理所需内存）       用户模式下的开销（线程局部存储、线程环境块、堆栈、CRT、MFC、COM等等等等）       通常，线程数目的瓶颈在于线程自己的堆栈。Visual C++编译器默认设置是每个线程的堆栈大小是1MB。当然，如果你在创建线程时指定较小的堆栈大小，你应该可以创建较多的线程。       但
slim读/写锁 srwlock
jiht594的专栏
05-03 697
Slim读/写锁 SRWLock （code） ****************************************************    2010-02-03 > > SRWLock： 区分读取者线程和写入者线程          让读取
读写锁SRWLock
nyzdmc的博客
03-14 556
SRWLock 读写锁在对资源进行保护的同时，还能区分想要读取资源值的线程（读取者线程）和想要更新资源的线程（写入者线程）: 对于读取者线程，读写锁会允许他们并发的执行。 当有写入者线程在占有资源时，读写锁会让其它写入者线程和读取者线程等待。 对于一个读写锁，有两种获取方式：共享（Shared）或独占（Exclusive）。 如果当前读写锁处于空闲状态，那么当多个线程同时以共享方式访问该...
多线程之SRWLOCK
for_casech的博客
03-02 322
下面就来看看如何使用读写锁，要注意编译读写锁程序需要VS2008，运行读写锁程序要在Vista或Windows Server2008系统（比这两个更高级的系统也可以）。读写锁的主要函数就五个，分为初始化函数，写入者线程申请和释放函数，读取者线程申请和释放函数，以下是详细的函数使用说明： 第一个 InitializeSRWLock 函数功能：初始化读写锁 函数原型：VOID Ini
多线程例子—读者，作家使用读写锁（SRWLOCK）
xietingcandice的专栏
08-20 915
1．读写锁声明后要初始化，但不用销毁，系统会自动清理读写锁。 2．读取者和写入者分别调用不同的申请函数和释放函数。
std::mutex （互斥量内部实现SRWLOCK）
杰克东的专栏
04-25 2473
注意：mutex windows vista 以上系统用SRWLOCK 实现，winxp用的是参考 rtlocks.cpp critical_section 调用InterlockedCompareExchangePointer 来实现的 Windows 7下 + vs2015 微软最新c++11 std::mutex 内部实现剖析 一、 先说说微软c++11 里面实现的代码，...
写优先读写锁，读效率比 WINDOWS 的 SRWLOCK 慢一倍左右，百万级读锁要156ms
IamRainLiang的专栏
07-16 4109
#pragma once /************************************************** 写优先读写锁 读效率比 WINDOWS 的 SRWLOCK 慢一倍左右，百万级读锁要156ms（78ms） 写效率比 WINDOWS 的 SRWLOCK 慢 N 倍，百万级写锁要1516ms（62ms） CKSRWLock 读写锁实现 CAut
C++多线程同步与单例模式笔记
在多线程编程中，确保资源的线程安全是非常重要的。`WFCCritical`类和`WFScopeLock`模板类提供了一种简洁且安全的方式来管理这部分代码，避免了数据竞争和其他并发问题。 同时，文件中提到的设计模式的单件模式...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值