分享一个临界许可类

urenai

重新编辑一下帖子，之前发过面向对象的临界类，这次分享的这个使用方式不一样。在创建时会返回指针，方便保存。干脆再次发一遍吧。
第一种：

变量 cs <类型 = 变整数>
cs = 临界.创建 ()
临界.进入 (cs)
临界.退出 (cs)
调试输出 (cs, 临界.尝试 (cs))
临界.销毁 (cs)

1. <火山程序 类型 = "通常" 版本 = 1 />
   
2. 
   
3. 类 临界 <公开 折叠>
   
4. {
   
5.     方法 创建 <公开 静态 类型 = 变整数 注释 = "创建许可证" 返回值注释 = "返回临界指针" @禁止流程检查 = 真>
   
6.     {
   
7.         @ LPCRITICAL_SECTION cs = new CRITICAL_SECTION;
   
8.         @ ::InitializeCriticalSection(cs);
   
9.         @ return (INT_P)cs;
   
10.     }
    
11. 
    
12.     方法 销毁 <公开 静态 注释 = "销毁许可证" @禁止流程检查 = 真>
    
13.     参数 lpCriticalSection <类型 = 变整数>
    
14.     {
    
15.         @ ::DeleteCriticalSection((LPCRITICAL_SECTION)@<lpCriticalSection>);
    
16.         @ delete (void*)@<lpCriticalSection>;
    
17.     }
    
18. 
    
19.     方法 进入 <公开 静态 注释 = "进入许可区" 折叠 @嵌入式方法 = "">
    
20.     参数 lpCriticalSection <类型 = 变整数>
    
21.     {
    
22.         @ ::EnterCriticalSection((LPCRITICAL_SECTION)@<lpCriticalSection>)
    
23.     }
    
24. 
    
25.     方法 退出 <公开 静态 注释 = "退出许可区" 折叠 @嵌入式方法 = "">
    
26.     参数 lpCriticalSection <类型 = 变整数>
    
27.     {
    
28.         @ ::LeaveCriticalSection((LPCRITICAL_SECTION)@<lpCriticalSection>)
    
29.     }
    
30. 
    
31.     方法 尝试 <公开 静态 类型 = 逻辑型 注释 = "尝试进入许可证" 折叠 @嵌入式方法 = "">
    
32.     参数 lpCriticalSection <类型 = 变整数>
    
33.     {
    
34.         @ (BOOL)::TryEnterCriticalSection((LPCRITICAL_SECTION)@<lpCriticalSection>)
    
35.     }
    
36. 
    
37.     #
    
38. }
    

复制代码

第二种：

变量 cs <类型 = 临界类>
调试输出(cs.尝试())
cs.进入 ()
cs.退出 ()

或者：
变量 cs <类型 = 变整数>
cs = 创建对象指针 (临界类)

调试输出 (读指针处对象 (cs, 临界类).尝试 ())
读指针处对象 (cs, 临界类).进入 ()
读指针处对象 (cs, 临界类).退出 ()

1. <火山程序 类型 = "通常" 版本 = 1 />
   
2. 
   
3. 类 临界类 <公开 "">
   
4. {
   
5. 
   
6.     # @begin
   
7.     # <> <include>
   
8.     # CRITICAL_SECTION cs;
   
9.     # <> </include>
   
10.     # @end
    
11. 
    
12.     方法 类_初始化 <"">
    
13.     {
    
14.         @ ::InitializeCriticalSection(&cs);
    
15.     }
    
16. 
    
17.     方法 类_清理
    
18.     {
    
19.         @ DeleteCriticalSection(&cs);
    
20.     }
    
21. 
    
22.     方法 进入 <公开 @嵌入式方法 = "">
    
23.     {
    
24.         @ EnterCriticalSection(&@sn<this>.cs)
    
25.     }
    
26. 
    
27.     方法 退出 <公开 编辑时信息 = "43FFB, 0, 0, 0" @嵌入式方法 = "">
    
28.     {
    
29.         @ LeaveCriticalSection(&@sn<this>.cs)
    
30.     }
    
31. 
    
32.     方法 尝试 <公开 类型 = 逻辑型 @嵌入式方法 = "">
    
33.     {
    
34.         @ TryEnterCriticalSection(&@sn<this>.cs)
    
35.     }
    
36. }
    

复制代码

呵呵仙8

创建和销毁.写在类_初始化和类_清理.好像更实用!

shuimiao

这个与互斥锁有啥区别

老道

shuimiao 发表于 2023-12-24 10:30
这个与互斥锁有啥区别

临界区是非内核对象，只在用户态进行锁操作，速度快；互斥锁是内核对象，在核心态进行锁操作，速度慢。论坛的这个代码分享有必要解析为表格显示。否则有点抽象！累眼睛。

shuimiao

老道 发表于 2023-12-24 11:05
临界区是非内核对象，只在用户态进行锁操作，速度快；互斥锁是内核对象，在核心态进行锁操作，速度慢。论 ...

除了速度快慢，在使用上有没有什么明显区别，会有些什么特殊差异吗？如果使用一样的话，那官方可以考虑把临界区封装到核心库，明显写上备注让人知道与互斥锁的差异

Xelloss0618

上面很多人是没看过核心库的源码……
火山的「互斥锁类」就是临界区（Critical Section），「同步事件类」才是互斥对象（Mutex）。
另外由于 Linux 没有临界区这玩意，所以 C++ 标准库只有互斥量 std::mutex。

Xelloss0618

呵呵仙8 发表于 2023-12-24 09:00
创建和销毁.写在类_初始化和类_清理.好像更实用!

他这个写法是面向过程的，不能触发类_初始化和清理，面向对象直接用核心库的 互斥锁类 就行了