mormot.core.os--TSynLocker和TSynLocked

冬雨财经  金牌会员 | 2024-7-9 13:15:36 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 851|帖子 851|积分 2553

mormot.core.os--TSynLocker和TSynLocked

TLightLock
  1. { **************** TSynLocker/TSynLocked 和 低级线程特性 }
  3. type
  4.   /// 一个轻量级的独占非重入锁，存储在 PtrUInt 值中
  5.   // - 在自旋一段时间后调用 SwitchToThread，但不使用任何读写操作系统API
  6.   // - 警告：方法是非重入的，即在一个裸调用中两次调用 Lock 会导致死锁：
  7.   //   对于需要重入方法的情况，请使用 TRWLock 或 TSynLocker/TOSLock
  8.   // - 多个轻量级锁，每个保护少量变量（如列表），可能比更全局的 TOSLock/TRWLock 更高效
  9.   // - 我们的轻量级锁预计保持时间非常短（几个CPU周期）：
  10.   //   如果锁可能阻塞太长时间，请使用 TSynLocker 或 TOSLock
  11.   // - TryLock/UnLock 可用于线程安全地获取共享资源
  12.   // - 在 CPU32 上占用 4 字节，在 CPU64 上占用 8 字节
  13.   {$ifdef USERECORDWITHMETHODS}
  14.   TLightLock = record
  15.   {$else}
  16.   TLightLock = object
  17.   {$endif USERECORDWITHMETHODS}
  18.   private
  19.     Flags: PtrUInt; // 标志位
  20.     // 由 Lock 方法在内联时调用的低级函数
  21.     procedure LockSpin;
  22.   public
  23.     /// 如果实例未被初始化为 0，则调用此方法
  24.     // - 例如，如果 TLightLock 被定义为类字段，则不需要此方法
  25.     procedure Init;
  26.       {$ifdef HASINLINE} inline; {$endif}
  27.   
  28.     /// 可用于将实例作为 TOSLock 进行终结处理
  29.     // - 不执行任何操作 - 仅与 TOSLock 兼容
  30.     procedure Done;
  31.       {$ifdef HASINLINE} inline; {$endif}
  32.   
  33.     /// 进入独占非重入锁
  34.     procedure Lock;
  35.       {$ifdef HASINLINE} inline; {$endif}
  36.   
  37.     /// 尝试进入独占非重入锁
  38.     // - 如果返回 true，则调用者最终应调用 UnLock()
  39.     // - 也可用于线程安全地获取共享资源
  40.     function TryLock: boolean;
  41.       {$ifdef HASINLINE} inline; {$endif}
  42.   
  43.     /// 检查独占非重入锁是否已被获取
  44.     function IsLocked: boolean;
  45.       {$ifdef HASINLINE} inline; {$endif}
  46.   
  47.     /// 离开独占非重入锁
  48.     procedure UnLock;
  49.       {$ifdef HASINLINE} inline; {$endif}
  50.   end;
复制代码
TRWLightLock
  1.   /// 一个轻量级的支持多个读操作/独占写操作的非升级锁
  2.   // - 在自旋一段时间后调用 SwitchToThread，但不使用任何读写操作系统API
  3.   // - 警告：读锁是可重入的并允许并发访问，但在读锁内部或另一个写锁内部调用 WriteLock 会导致死锁
  4.   // - 如果您需要一个可升级的锁，请考虑使用 TRWLock - 但对于大多数读操作，
  5.   //   TRWLightLock.ReadLock/ReadUnLock/WriteLock 模式比升级更快
  6.   // - 我们的轻量级锁预计保持时间非常短（几个CPU周期）：
  7.   //   如果锁可能阻塞太长时间，请使用 TSynLocker 或 TOSLock
  8.   // - 多个轻量级锁，每个保护少量变量（如列表），可能比更全局的 TOSLock/TRWLock 更高效
  9.   // - 在 CPU32 上占用 4 字节，在 CPU64 上占用 8 字节
  10.   {$ifdef USERECORDWITHMETHODS}
  11.   TRWLightLock = record
  12.   {$else}
  13.   TRWLightLock = object
  14.   {$endif USERECORDWITHMETHODS}
  15.   private
  16.     Flags: PtrUInt; // 标志位，位 0 = 写锁，>0 = 读锁计数器
  17.     // 由 Lock 方法在内联时调用的低级函数
  18.     procedure ReadLockSpin;
  19.     procedure WriteLockSpin;
  20.   public
  21.     /// 如果实例未被初始化为 0，则调用此方法
  22.     // - 例如，如果 TRWLightLock 被定义为类字段，则不需要此方法
  23.     procedure Init;
  24.       {$ifdef HASINLINE} inline; {$endif}
  25.   
  26.     /// 进入不可升级的多读锁
  27.     // - 读锁维护一个线程安全的计数器，因此是可重入和非阻塞的
  28.     // - 警告：在读锁之后嵌套调用 WriteLock 会导致死锁
  29.     procedure ReadLock;
  30.       {$ifdef HASINLINE} inline; {$endif}
  31.   
  32.     /// 尝试进入不可升级的多读锁
  33.     // - 如果返回 true，则调用者最终应调用 ReadUnLock
  34.     // - 读锁维护一个线程安全的计数器，因此是可重入和非阻塞的
  35.     // - 警告：在读锁之后嵌套调用 WriteLock 会导致死锁
  36.     function TryReadLock: boolean;
  37.       {$ifdef HASINLINE} inline; {$endif}
  38.   
  39.     /// 离开不可升级的多读锁
  40.     procedure ReadUnLock;
  41.       {$ifdef HASINLINE} inline; {$endif}
  42.   
  43.     /// 进入不可重入且不可升级的独占写锁
  44.     // - 警告：在读锁或另一个写锁之后嵌套调用 WriteLock 会导致死锁
  45.     procedure WriteLock;
  46.       {$ifdef HASINLINE} inline; {$endif}
  47.   
  48.     /// 尝试进入不可重入且不可升级的独占写锁
  49.     // - 如果返回 true，则调用者最终应调用 WriteUnLock
  50.     // - 警告：在读锁或另一个写锁之后嵌套调用 TryWriteLock 会导致死锁
  51.     function TryWriteLock: boolean;
  52.       {$ifdef HASINLINE} inline; {$endif}
  53.   
  54.     /// 离开不可重入且不可升级的独占写锁
  55.     procedure WriteUnLock;
  56.       {$ifdef HASINLINE} inline; {$endif}
  57.   end;
复制代码
TLockedList
  1. /// 指向TLockedList中一个数据条目的指针
  2. PLockedListOne = ^TLockedListOne;
  4. /// TLockedList中一个数据条目的抽象父类，存储两个PLockedListOne指针
  5. // - TLockedList应该存储以这些字段开头的非托管记录
  6. // - sequence字段包含一个递增的、基于随机种子的30位整数（大于65535），
  7. //   以避免实例回收时出现的ABA问题
  8. TLockedListOne = record
  9.     next, prev: pointer;  // 指向下一个和上一个条目的指针
  10.     sequence: PtrUInt;    // 序列号，用于解决ABA问题
  11. end;
  13. /// 用于终结一个TLockedListOne实例的可选回调事件
  14. TOnLockedListOne = procedure(one: PLockedListOne) of object;
  16. /// 线程安全的双链表，包含TLockedListOne后代的回收机制
  17. {$ifdef USERECORDWITHMETHODS}
  18. TLockedList = record
  19. {$else}
  20. TLockedList = object
  21. {$endif USERECORDWITHMETHODS}
  22. private
  23.     fHead, fBin: pointer;  // 分别指向链表头部和回收箱的指针
  24.     fSize: integer;        // 列表中每个实例的大小（包括TLockedListOne头部）
  25.     fSequence: PtrUInt;    // 全局序列号生成器
  26.     fOnFree: TOnLockedListOne; // 当实例被释放时调用的回调
  27. public
  28.     /// 线程安全的访问锁
  29.     Safe: TLightLock;
  30.   
  31.     /// 当前列表中存储的TLockedListOne实例数量（不包括回收箱中的实例）
  32.     Count: integer;
  33.   
  34.     /// 初始化继承自TLockedListOne的大小的存储
  35.     procedure Init(onesize: PtrUInt; const onefree: TOnLockedListOne = nil);
  36.   
  37.     /// 释放所有存储的内存
  38.     procedure Done;
  39.   
  40.     /// 在线程安全的O(1)过程中分配一个新的PLockedListOne数据实例
  41.     function New: pointer;
  42.   
  43.     /// 在线程安全的O(1)过程中释放一个已使用的PLockedListOne数据实例
  44.     function Free(one: pointer): boolean;
  45.   
  46.     /// 释放当前存储在此列表中的所有TLockedListOne实例
  47.     // - 不会将任何实例移动到内部回收箱
  48.     procedure Clear;
  49.   
  50.     /// 释放内部回收箱中所有待回收的项
  51.     // - 返回从内部收集器中释放了多少项
  52.     function EmptyBin: integer;
  53.   
  54.     /// 作为PLockedListOne双链表的原始访问存储的项
  55.     property Head: pointer
  56.       read fHead;
  57.   
  58.     /// 存储的每个实例的大小，包括其TLockedListOne头部
  59.     property Size: integer
  60.       read fSize;
  61. end;
复制代码
TSynLocker
  1. type  
  2.   /// TSynLocker处理线程同步的方式  
  3.   // - 默认情况下，uSharedLock将使用主TRTLCriticalSection  
  4.   // - 您可以设置uRWLock并调用重载的RWLock/RWUnLock()来使用更轻量级的TRWLock - 但请注意，cReadOnly后跟cReadWrite/cWrite会导致死锁 - 常规的Lock/UnLock将使用cWrite独占锁  
  5.   // - uNoLock将禁用整个锁定机制  
  6.   TSynLockerUse = (  
  7.     uSharedLock,  
  8.     uRWLock,  
  9.     uNoLock);  
  10.   
  11.   /// 允许向任何类实例添加跨平台锁定方法  
  12.   // - 典型用途是定义一个Safe: TSynLocker属性，在构造函数/析构函数方法中调用Safe.Init和Safe.Done，并在try ... finally部分使用Safe.Lock/UnLock方法  
  13.   // - 相对于TCriticalSection类，修复了可能降低多线程性能的CPU缓存行冲突问题，如http://www.delphitools.info/2011/11/30/fixing-tcriticalsection所述  
  14.   // - 内部填充用于安全存储最多7个受互斥锁保护的值，因此SizeOf(TSynLocker)>128  
  15.   // - 对于对象级锁定，请参阅TSynPersistentLock，它拥有一个此类实例，或在构造函数中调用低级fSafe := NewSynLocker，然后在析构函数中调用fSafe^.DoneAndFreemem  
  16.   // - RWUse属性可以将TRTLCriticalSection替换为更轻量级的TRWLock  
  17.   // - 如果多读/独占写锁更合适（仅当锁定过程不会花费太多时间时），请参阅TRWLock和TSynPersistentRWLock  
  18.   {$ifdef USERECORDWITHMETHODS}  
  19.   TSynLocker = record  
  20.   {$else}  
  21.   TSynLocker = object  
  22.   {$endif USERECORDWITHMETHODS}  
  23.   private  
  24.     fSection: TRTLCriticalSection; // 主同步对象  
  25.     fRW: TRWLock; // 可选的读写锁  
  26.     fPaddingUsedCount: byte; // 填充区已使用计数  
  27.     fInitialized: boolean; // 初始化标志  
  28.     fRWUse: TSynLockerUse; // 锁使用模式  
  29.     fLockCount: integer; // 锁计数（用于重入）  
  30.     // 以下为用于安全访问内部填充数据的辅助方法  
  31.     function GetVariant(Index: integer): Variant;  
  32.     procedure SetVariant(Index: integer; const Value: Variant);  
  33.     function GetInt64(Index: integer): Int64;  
  34.     procedure SetInt64(Index: integer; const Value: Int64);  
  35.     function GetBool(Index: integer): boolean;  
  36.     procedure SetBool(Index: integer; const Value: boolean);  
  37.     function GetUnlockedInt64(Index: integer): Int64;  
  38.     procedure SetUnlockedInt64(Index: integer; const Value: Int64);  
  39.     function GetPointer(Index: integer): Pointer;  
  40.     procedure SetPointer(Index: integer; const Value: Pointer);  
  41.     function GetUtf8(Index: integer): RawUtf8;  
  42.     procedure SetUtf8(Index: integer; const Value: RawUtf8);  
  43.     function GetIsLocked: boolean;  
  44.     // - 如果RWUse=uSharedLock，则调用EnterCriticalSection（不支持并行读取）  
  45.     // - 警告：如果RWUse=uRWLock，则此方法将使用内部TRWLock  
  46.     // - 在受保护部分中定义，以便更好地内联并修复Delphi编译器关于uses classes中缺少Windows单元的警告  
  47.     procedure RWLock(context: TRWLockContext);  
  48.       {$ifdef HASINLINE} inline; {$endif}  
  49.     procedure RWUnLock(context: TRWLockContext);  
  50.       {$ifdef HASINLINE} inline; {$endif}  
  51.   public  
  52.     /// 内部填充数据，也用于存储最多7个Variant值  
  53.     // - 这个内存缓冲区将确保不会发生CPU缓存行混合  
  54.     // - 您不应直接使用此字段，而应使用Locked[], LockedInt64[], LockedUtf8[]或LockedPointer[]方法  
  55.     // - 如果您要访问这些数组值，请确保在try ... finally结构中保护它们，并使用Safe.Lock和Safe.Unlock，同时准确维护PaddingUsedCount属性  
  56.     Padding: array[0..6] of TVarData;  
  57.   
  58.     /// 初始化互斥锁  
  59.     // - 调用此方法是强制性的（例如，在拥有TSynLocker实例的类构造函数中），否则您可能会遇到意外的行为，如访问违规或内存泄漏  
  60.     procedure Init;  
  61.    
  62.     /// 终结互斥锁  
  63.     // - 调用此方法是强制性的（例如，在拥有TSynLocker实例的类析构函数中），否则您可能会遇到意外的行为，如访问违规或内存泄漏  
  64.     procedure Done;  
  65.   
  66.     /// 终结互斥锁，并对实例的指针调用FreeMem()  
  67.     // - 应该通过NewSynLocker调用来初始化  
  68.     procedure DoneAndFreeMem;  
  69.   
  70.     /// 低级锁定获取，相当于RWLock(cReadOnly)  
  71.     // - 如果RWUse=uSharedLock，则调用EnterCriticalSection（不支持并行读取）  
  72.     // - 警告：如果RWUse=uRWLock，则嵌套的Lock调用会导致死锁，但嵌套的ReadLock调用不会  
  73.     procedure ReadLock;  
  74.   
  75.     /// 低级锁定释放，相当于RWUnLock(cReadOnly)  
  76.     procedure ReadUnLock;  
  77.   
  78.     /// 低级锁定获取，相当于RWLock(cReadWrite)  
  79.     // - 如果RWUse=uSharedLock，则调用EnterCriticalSection（不支持并行读取）  
  80.     // - 如果RWUse=uRWLock，则嵌套的Lock调用不会导致死锁  
  81.     procedure ReadWriteLock;  
  82.     /// 低级锁定释放，相当于RWUnLock(cReadWrite)  
  83.     procedure ReadWriteUnLock;  
  84.   
  85.     /// 对实例进行独占访问锁定，相当于RWLock(cWrite)  
  86.     // - 从同一线程是可重入的，即您可以嵌套Lock/UnLock调用  
  87.     // - 警告：如果RWUse=uRWLock，则在嵌套ReadLock之后会导致死锁，但在ReadWriteLock之后不会  
  88.     // - 使用此类结构以避免竞态条件（从Safe: TSynLocker属性）：  
  89.     // ! Safe.Lock;  
  90.     // ! try  
  91.     // !   ...  
  92.     // ! finally  
  93.     // !   Safe.Unlock;  
  94.     // ! end;  
  95.     procedure Lock;  
  96.   
  97.     /// 尝试获取互斥锁  
  98.     // - 如果RWUse不是默认的uSharedLock，则什么也不做并返回false  
  99.     // - 使用此类结构以避免竞态条件（从Safe: TSynLocker属性）：  
  100.     // ! if Safe.TryLock then  
  101.     // !   try  
  102.     // !     ...  
  103.     // !   finally  
  104.     // !     Safe.Unlock;  
  105.     // !   end;  
  106.     function TryLock: boolean;  
  107.   
  108.     /// 尝试在给定的时间内获取互斥锁  
  109.     // - 如果RWUse不是默认的uSharedLock，则只是等待并返回false  
  110.     // - 使用此类结构以避免竞态条件（从Safe: TSynLocker属性）：  
  111.     // ! if Safe.TryLockMS(100) then  
  112.     // !   try  
  113.     // !     ...  
  114.     // !   finally  
  115.     // !     Safe.Unlock;  
  116.     // !   end;  
  117.     function TryLockMS(retryms: integer; terminated: PBoolean = nil): boolean;  
  118.   
  119.     /// 释放实例的独占访问权，相当于RWUnLock(cWrite)  
  120.     // - 每个Lock/TryLock调用都应该有一个对应的UnLock调用，因此try..finally块是安全代码所必需的  
  121.     procedure UnLock; overload;  
  122.     /// 将进入互斥锁，直到释放IUnknown引用  
  123.     // - 在Delphi中可以这样使用：  
  124.     // !begin  
  125.     // !  ... // 不安全代码  
  126.     // !  Safe.ProtectMethod;  
  127.     // !  ... // 线程安全代码  
  128.     // !end; // 局部变量隐藏的IUnknown将释放方法的锁  
  129.     // - 警告：在FPC中，您应该将结果分配给局部变量 - 请参阅bug http://bugs.freepascal.org/view.php?id=26602  
  130.     // !var  
  131.     // !  LockFPC: IUnknown;  
  132.     // !begin  
  133.     // !  ... // 不安全代码  
  134.     // !  LockFPC := Safe.ProtectMethod;  
  135.     // !  ... // 线程安全代码  
  136.     // !end; // LockFPC将释放方法的锁  
  137.     // 或  
  138.     // !begin  
  139.     // !  ... // 不安全代码  
  140.     // !  with Safe.ProtectMethod do  
  141.     // !  begin  
  142.     // !    ... // 线程安全代码  
  143.     // !  end; // 局部变量隐藏的IUnknown将释放方法的锁  
  144.     // !end;  
  145.     function ProtectMethod: IUnknown;  
  146.   
  147.     /// 存储在内部Padding[]数组中的值数  
  148.     // - 如果没有存储任何值，则为0，否则为1..7之间的数字  
  149.     // - 您通常不需要使用此字段，但对于在Lock/UnLock安全块内优化对Padding[]值的低级直接访问，它是必要的  
  150.     property PaddingUsedCount: byte  
  151.       read fPaddingUsedCount write fPaddingUsedCount;  
  152.   
  153.     /// 如果互斥锁当前被另一个线程锁定，则返回true  
  154.     // - 如果RWUse=uRWLock，则任何锁（即使是ReadOnlyLock）也会返回true
  155.     property IsLocked: boolean
  156.       read GetIsLocked;
  157.   
  158.     /// 如果已为此互斥锁调用Init方法，则返回true
  159.     // - 仅当整个对象之前已被填充为0时（即作为类的一部分或作为全局变量），这一点才相关，但如果是在堆栈上分配的，则可能不准确
  160.     property IsInitialized: boolean
  161.       read fInitialized;
  162.   
  163.     /// 安全锁定访问Variant值
  164.     // - 您可以存储最多7个变量，使用0..6索引，与LockedBool、LockedInt64、LockedPointer和LockedUtf8数组属性共享
  165.     // - 如果索引超出范围，则返回null
  166.     // - 如果RWUse设置为uRWLock，则允许并发线程读取
  167.     property Locked[Index: integer]: Variant
  168.       read GetVariant write SetVariant;
  169.   
  170.     /// 安全锁定访问Int64值
  171.     // - 您可以存储最多7个变量，使用0..6索引，与Locked和LockedUtf8数组属性共享
  172.     // - Int64将作为varInt64变体内部存储
  173.     // - 如果索引超出范围或不存储Int64，则返回nil
  174.     // - 如果RWUse设置为uRWLock，则允许并发线程读取
  175.     property LockedInt64[Index: integer]: Int64
  176.       read GetInt64 write SetInt64;
  177.   
  178.     /// 安全锁定访问布尔值
  179.     // - 您可以存储最多7个变量，使用0..6索引，与Locked、LockedInt64、LockedPointer和LockedUtf8数组属性共享
  180.     // - 值将作为varboolean变体内部存储
  181.     // - 如果索引超出范围或不存储布尔值，则返回nil
  182.     // - 如果RWUse设置为uRWLock，则允许并发线程读取
  183.     property LockedBool[Index: integer]: boolean
  184.       read GetBool write SetBool;
  185.    
  186.     /// 安全锁定访问指针/TObject值
  187.     // - 您可以存储最多7个变量，使用0..6索引，与Locked、LockedBool、LockedInt64和LockedUtf8数组属性共享
  188.     // - 指针将作为varUnknown变体内部存储
  189.     // - 如果索引超出范围或不存储指针，则返回nil
  190.     // - 如果RWUse设置为uRWLock，则允许并发线程读取
  191.     property LockedPointer[Index: integer]: Pointer
  192.       read GetPointer write SetPointer;
  193.   
  194.     /// 安全锁定访问UTF-8字符串值
  195.     // - 您可以存储最多7个变量，使用0..6索引，与Locked和LockedPointer数组属性共享
  196.     // - UTF-8字符串将作为varString变体内部存储
  197.     // - 如果索引超出范围或不存储字符串，则返回''
  198.     // - 如果RWUse设置为uRWLock，则允许并发线程读取
  199.     property LockedUtf8[Index: integer]: RawUtf8
  200.       read GetUtf8 write SetUtf8;
  201.   
  202.     /// 安全锁定就地递增Int64值
  203.     // - 您可以存储最多7个变量，使用0..6索引，与Locked和LockedUtf8数组属性共享
  204.     // - Int64将作为varInt64变体内部存储
  205.     // - 返回新存储的值
  206.     // - 如果内部值尚未定义，则默认使用0
  207.     function LockedInt64Increment(Index: integer; const Increment: Int64): Int64;
  208.   
  209.     /// 安全锁定就地交换Variant值
  210.     // - 您可以存储最多7个变量，使用0..6索引，与Locked和LockedUtf8数组属性共享
  211.     // - 返回之前存储的值，如果索引超出范围，则返回null
  212.     function LockedExchange(Index: integer; const Value: variant): variant;
  213.   
  214.     /// 安全锁定就地交换指针/TObject值
  215.     // - 您可以存储最多7个变量，使用0..6索引，与Locked和LockedUtf8数组属性共享
  216.     // - 指针将作为varUnknown变体内部存储
  217.     // - 返回之前存储的值，如果索引超出范围或不存储指针，则返回nil
  218.     function LockedPointerExchange(Index: integer; Value: pointer): pointer;
  219.   
  220.     /// 不安全访问Int64值
  221.     // - 您可以存储最多7个变量，使用0..6索引，与Locked和LockedUtf8数组属性共享
  222.     // - Int64将作为varInt64变体内部存储
  223.     // - 如果索引超出范围或不存储Int64，则返回nil
  224.     // - 您应该调用LockedInt64[]属性，或使用此属性并在Lock; try ... finally UnLock块中使用
  225.     property UnlockedInt64[Index: integer]: Int64
  226.       read GetUnlockedInt64 write SetUnlockedInt64;
  227.   
  228.     /// RWLock/RWUnLock的处理方式
  229.     property RWUse: TSynLockerUse
  230.       read fRWUse write fRWUse;
  231.   end;
复制代码
这段代码定义了一个 TSynLocker类型，它允许跨平台地为任何类实例添加锁定方法，以确保线程安全。它提供了多种锁定机制（如共享锁、读写锁和无锁），以及安全访问内部存储的值的方法。这些特性使得 TSynLocker成为处理多线程编程中同步题目的一个强盛工具。
TAutoLock
  1. /// 指向TSynLocker互斥锁实例的指针
  2. // - 另请参见NewSynLocker和TSynLocker.DoneAndFreemem函数
  3. PSynLocker = ^TSynLocker;
  5. /// TAutoLocker.ProtectMethod和TSynLocker.ProtectMethod使用的原始类
  6. // - 在此定义以供mormot.core.data.pas中的TAutoLocker使用
  7. TAutoLock = class(TInterfacedObject)
  8. protected
  9.     fLock: PSynLocker; // 指向TSynLocker的指针
  10. public
  11.     constructor Create(aLock: PSynLocker); // 构造函数，接受一个PSynLocker参数
  12.     destructor Destroy; override; // 析构函数，重写自TInterfacedObject
  13. end;
复制代码
TSynEvent
  1. /// 我们的轻量级跨平台TEvent类似组件
  2. // - 在Windows上，直接调用CreateEvent/ResetEvent/SetEvent API
  3. // - 在Linux上，将使用阻塞和非信号量模式的eventfd()
  4. // - 在其他POSIX系统上，将使用比TEvent BasicEvent更轻的PRTLEvent
  5. // - 唯一限制是我们不知道WaitFor是被信号触发还是超时，
  6. // 但实际上这并不是一个大问题，因为大多数代码不需要这个信息
  7. // 或者已经在其实现逻辑中有了自己的标志
  8. TSynEvent = class
  9. protected
  10.     fHandle: pointer; // Windows THandle或FPC PRTLEvent
  11.     fFD: integer;     // 用于eventfd()
  12. public
  13.     /// 初始化跨平台事件实例
  14.     constructor Create;
  15.     /// 终结跨平台事件实例
  16.     destructor Destroy; override;
  17.     /// 忽略任何挂起的事件，以便WaitFor将在下次SetEvent时被设置
  18.     procedure ResetEvent;
  19.       {$ifdef OSPOSIX} inline; {$endif}
  20.     /// 触发任何挂起的事件，释放WaitFor/WaitForEver方法
  21.     procedure SetEvent;
  22.       {$ifdef OSPOSIX} inline; {$endif}
  23.     /// 等待，直到另一个线程调用SetEvent，具有最大时间
  24.     // - 如果被信号触发或超时，则不返回
  25.     // - 警告：您应该一次只从一个线程等待
  26.     procedure WaitFor(TimeoutMS: integer);
  27.       {$ifdef OSPOSIX} inline; {$endif}
  28.     /// 无限期等待，直到另一个线程调用SetEvent
  29.     procedure WaitForEver;
  30.       {$ifdef OSPOSIX} inline; {$endif}
  31.     /// 在检查终止标志和此事件的同时，分步骤调用SleepHiRes()
  32.     function SleepStep(var start: Int64; terminated: PBoolean): Int64;
  33.     /// 如果使用了eventfd() API，则可用于调整算法
  34.     function IsEventFD: boolean;
  35.       {$ifdef HASINLINE} inline; {$endif}
  36. end;
复制代码
NewSynLocker
  1. /// 从堆初始化一个TSynLocker实例
  2. // - 调用DoneandFreeMem来释放相关内存和操作系统互斥锁
  3. // - 例如，在TSynPersistentLock中使用以减少类实例大小
  4. function NewSynLocker: PSynLocker;
复制代码
TSynLocked
  1. type
  2.   {$M+} // 开启内存管理消息
  4.   /// TSynPersistentLock的一个持久性无关替代方案
  5.   // - 当不需要自定义JSON持久性时，可以用作基类
  6.   // - 可以考虑将TRWLock字段用作更轻量级的多读/独占写选项
  7.   TSynLocked = class
  8.   protected
  9.     fSafe: PSynLocker; // TSynLocker会增加继承字段的偏移量
  10.   public
  11.     /// 初始化实例及其关联的锁
  12.     // - 定义为virtual，就像TObjectWithCustomCreate/TSynPersistent一样
  13.     constructor Create; virtual;
  14.     /// 终结实例及其关联的锁
  15.     destructor Destroy; override;
  16.     /// 访问关联的实例临界区
  17.     // - 调用Safe.Lock/UnLock来保护此存储的多线程访问
  18.     property Safe: PSynLocker
  19.       read fSafe;
  20.   end;
  22.   {$M-} // 关闭内存管理消息
  24.   /// TSynLocked层次的元类定义
  25.   TSynLockedClass = class of TSynLocked;
复制代码
TLecuyerThreadSafe
  1.   /// 线程安全的Pierre L'Ecuyer软件随机数生成器
  2.   // - 仅用TLightLock包装TLecuyer
  3.   // - 除非可能比threadvar稍快，否则不应使用
  4.   {$ifdef USERECORDWITHMETHODS}
  5.   TLecuyerThreadSafe = record
  6.   {$else}
  7.   TLecuyerThreadSafe = object
  8.   {$endif USERECORDWITHMETHODS}
  9.   public
  10.     Safe: TLightLock;
  11.     Generator: TLecuyer;
  12.     /// 计算下一个生成的32位值
  13.     function Next: cardinal; overload;
  14.     /// 计算一个64位浮点数
  15.     function NextDouble: double;
  16.     /// 用随机字节异或某个内存缓冲区
  17.     procedure Fill(dest: pointer; count: integer);
  18.     /// 用7位ASCII随机文本填充某个string[31]
  19.     procedure FillShort31(var dest: TShort31);
  20.   end;
  22.   TThreadIDDynArray = array of TThreadID; // 线程ID动态数组类型
  26. var
  27.   /// 全局线程安全的Pierre L'Ecuyer软件随机数生成器
  28.   // - 除非可能比threadvar稍快，否则不应使用
  29.   SharedRandom: TLecuyerThreadSafe;
复制代码
与线程、CPU核心和事件相干的类型和函数

[code]{$ifdef OSPOSIX}  /// 可设置为TRUE，以欺压SleepHiRes(0)调用POSIX sched_yield  // - 在实践中，据报道在POSIX体系上存在题目  // - 即使是Linus Torvalds本人也对它的利用表示愤怒 - 例如，请参见  // https://www.realworldtech.com/forum/?threadid=189711&curpostid=189752  // - 您可以自己尝试它  SleepHiRes0Yield: boolean = false;{$endif OSPOSIX}/// 类似于Windows的sleep() API调用，真正实现跨平台// - 利用毫秒级分辨率// - SleepHiRes(0)在Windows上调用ThreadSwitch，但在POSIX版本中将等待10微秒// 除非欺压SleepHiRes0Yield为true（坏主意）// - 相对于RTL的Sleep()函数，如果在任何OS信号中断时返回ESysEINTR// - 警告：通常在Windows上等待下一个体系计时器中断，默认为每16毫秒一次；// 因此，永远不要依赖提供的毫秒值来猜测经过的时间，而应调用GetTickCount64procedure SleepHiRes(ms: cardinal); overload;/// 类似于Windows的sleep() API调用，但真正实现跨平台// 并在等待期间检查Terminated标志以快速响应中断// - 如果terminated^被设置为true（terminatedvalue），则返回truefunction SleepHiRes(ms: cardinal; var terminated: boolean;  terminatedvalue: boolean = true): boolean; overload;/// 调用SleepHiRes()，思量活动的步长，在0/1/5/50/120-250毫秒步长中// - 范围设计激进，以响应性为代价燃烧一些CPU// - 当发生某些活动时，应重置start := 0，或在Windows上设置start := -1// 以避免任何SleepHiRes(0) = SwitchToThread调用// - 可选地在terminated^被设置或事件被信号触发时返回// - 返回当前的GetTickCount64值function SleepStep(var start: Int64; terminated: PBoolean = nil): Int64;/// 计算最佳就寝时间作为0/1/5/50然后120-250毫秒步长// - 范围设计激进，以响应性为代价燃烧一些CPUfunction SleepDelay(elapsed: PtrInt): PtrInt;/// 计算最佳就寝时间，类似于SleepStep，在0/1/5/50/120-250毫秒步长中// - 范围设计激进，以响应性为代价燃烧一些CPU// - start=0将用tix填充其值，start
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

冬雨财经

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表