mormot.core.threads--TBlockingProcess

mormot.core.threads--TBlockingProcess

type
  /// TBlockingProcess 实例的当前状态
  TBlockingEvent = (
    evNone,       // 无状态
    evWaiting,    // 等待状态
    evTimeOut,    // 超时状态
    evRaised);    // 触发状态

  {$M+} // 开启内存管理消息,用于调试
  /// 用于等待某个进程完成的信号量
  // - 例如,在mormot.rest.server.pas中的TBlockingCallback使用
  // - 一旦创建,进程将通过WaitFor调用阻塞,当后台线程调用NotifyFinished时释放
  TBlockingProcess = class(TSynEvent)
  protected
    fTimeOutMs: integer;       // 超时毫秒数
    fEvent: TBlockingEvent;    // 当前事件状态
    fOwnedSafe: boolean;       // 是否拥有同步锁
    fSafe: PSynLocker;         // 同步锁指针
    procedure ResetInternal; virtual; // 重置关联参数(可重写)
  public
    /// 初始化信号量实例
    // - 指定阻塞执行应视为失败的超时毫秒数(如果设置为0,则使用默认值3000)
    // - 应提供一个关联的互斥锁
    constructor Create(aTimeOutMs: integer; aSafe: PSynLocker);
      reintroduce; overload; virtual;
    /// 初始化信号量实例
    // - 指定阻塞执行应视为失败的超时毫秒数(如果设置为0,则使用默认值3000)
    // - 将创建并拥有一个关联的互斥锁
    constructor Create(aTimeOutMs: integer); reintroduce; overload; virtual;
    /// 销毁实例
    destructor Destroy; override;
    /// 等待NotifyFinished()被调用或触发超时
    // - 返回进程的最终状态,即evRaised或evTimeOut
    function WaitFor: TBlockingEvent; reintroduce; overload; virtual;
    /// 等待NotifyFinished()被调用或指定超时时间后触发超时
    // - 返回进程的最终状态,即evRaised或evTimeOut
    function WaitFor(TimeOutMS: integer): TBlockingEvent; reintroduce; overload; virtual;
    /// 应在后台进程完成时调用
    // - 调用者随后将允许其WaitFor方法返回
    // - 如果成功(即状态不是evRaised或evTimeout),则返回TRUE
    // - 如果实例已被锁定(例如,从TBlockingProcessPool.FromCallLocked检索时),您可以设置alreadyLocked=TRUE
    function NotifyFinished(alreadyLocked: boolean = false): boolean; virtual;
    /// 重置内部事件状态为evNone的包装器
    // - 在WaitFor/NotifyFinished过程成功后,可用于重用相同的TBlockingProcess实例
    // - 如果成功(即状态不是evWaiting),则返回TRUE,并将当前状态设置为evNone,并将Call属性设置为0
    // - 如果有WaitFor当前正在进行,则返回FALSE
    function Reset: boolean; virtual;
    /// 围绕fSafe^.Lock的包装器
    procedure Lock;
    /// 围绕fSafe^.Unlock的包装器
    procedure Unlock;
  published
    /// 进程的当前状态
    // - 在WaitFor过程后,使用Reset方法来重用此实例
    property Event: TBlockingEvent
      read fEvent;
    /// 构造函数中定义的超时周期(毫秒)
    property TimeOutMs: integer
      read fTimeOutMS;
  end;
  {$M-} // 关闭内存管理消息

  /// 用于标识每个TBlockingProcessPool调用的类型
  // - 允许匹配给定的TBlockingProcessPoolItem信号量
  TBlockingProcessPoolCall = type integer;

  /// 在TBlockingProcessPool中使用的信号量
  // - 该信号量具有一个Call字段来标识每次执行
  TBlockingProcessPoolItem = class(TBlockingProcess)
  protected
    fCall: TBlockingProcessPoolCall; // 调用标识符
    procedure ResetInternal; override; // 重置内部状态
  published
    /// 当由TBlockingProcessPool拥有时的唯一标识符
    // - Reset会将此字段恢复为其默认值0
    property Call: TBlockingProcessPoolCall
      read fCall;
  end;

  /// TBlockingProcess的类引用类型(元类)
  TBlockingProcessPoolItemClass = class of TBlockingProcessPoolItem;

  /// 管理TBlockingProcessPoolItem实例的池
  // - 每个调用将通过唯一的TBlockingProcessPoolCall值进行标识
  // - 用于模拟例如从异步事件驱动DDD进程中的阻塞执行
  // - 它还允许重用TEvent系统资源
  TBlockingProcessPool = class(TSynPersistent)
  protected
    fClass: TBlockingProcessPoolItemClass; // 池项类
    fPool: TSynObjectListLightLocked;      // 池
    fCallCounter: TBlockingProcessPoolCall; // 设置TBlockingProcessPoolItem.Call
  public
    /// 初始化池,对于给定的实现类
    constructor Create(aClass: TBlockingProcessPoolItemClass = nil); reintroduce;
    /// 销毁池
    // - 还将强制所有挂起的WaitFor触发evTimeOut
    destructor Destroy; override;
    /// 从内部池中预订一个TBlockingProcess
    // - 出错时返回nil(例如,实例正在销毁)
    // - 或者返回与此调用相对应的阻塞进程实例;
    // 其Call属性将标识异步回调的调用,然后在WaitFor之后,应运行Reset方法来释放池的互斥锁
    function NewProcess(aTimeOutMs: integer): TBlockingProcessPoolItem; virtual;
    /// 从其调用标识符检索TBlockingProcess
    // - 可用于例如从异步进程的回调中
    // 设置继承自TBlockingProcess的一些附加参数,
    // 然后调用NotifyFinished来释放调用者的WaitFor
    // - 如果leavelocked为TRUE,则返回的实例将被锁定:调用者应在使用后执行result.Unlock或NotifyFinished(true)
    function FromCall(call: TBlockingProcessPoolCall;
      locked: boolean = false): TBlockingProcessPoolItem; virtual;
  end;

根据上述类定义编写的 TBlockingProcessTBlockingProcessPool的例程代码。请注意,由于这些类可能依赖于特定的库(如mORMot),以下示例将尽量保持通用性,并假设您已经有一个适当的环境来运行这些代码。

TBlockingProcess 例程代码

uses
  SysUtils, Classes, // 引入SysUtils和Classes单元以使用WriteLn和TSynLocker等
  // 假设YourSynapseUnit包含了TSynLocker和TBlockingProcess的定义
  YourSynapseUnit;

var
  Process: TBlockingProcess;
  EventState: TBlockingEvent;
  Safe: TSynLocker;

begin
  try
    // 创建一个同步锁
    Safe := TSynLocker.Create;
    try
      // 创建一个TBlockingProcess实例,超时设置为5000毫秒,并传递同步锁
      Process := TBlockingProcess.Create(5000, @Safe);
      try
        // 模拟异步操作,这里我们直接调用WaitFor来阻塞当前线程
        EventState := Process.WaitFor;
        case EventState of
          evNone: WriteLn('Process state is evNone (should not happen)');
          evWaiting: WriteLn('Process state is evWaiting (should not happen during WaitFor)');
          evTimeOut: WriteLn('Process timed out');
          evRaised: WriteLn('Process was notified successfully');
        end;

        // 在实际应用中,这里可能是另一个线程调用NotifyFinished来释放WaitFor
        // 但为了演示,我们直接调用NotifyFinished(尽管这在实际应用中可能是不必要的)
        if Process.NotifyFinished then
          WriteLn('NotifyFinished called successfully (for demonstration purposes only)');

        // 重置TBlockingProcess实例以供重用(如果需要的话)
        // 在这个例子中,我们不会重用它,但展示如何调用Reset
        if Process.Reset then
          WriteLn('Process reset successfully');

      finally
        // 销毁TBlockingProcess实例
        Process.Free;
      end;
    finally
      // 销毁同步锁
      Safe.Free;
    end;
  except
    on E: Exception do
      WriteLn('Error: ' + E.Message);
  end;
end.

注意:在上面的示例中,NotifyFinished的调用可能是不必要的,因为在实际应用中,它通常是由另一个线程在异步操作完成时调用的。此外,Reset的调用也取决于您是否需要重用 TBlockingProcess实例。

TBlockingProcessPool 例程代码

uses
  SysUtils, Classes, // 引入SysUtils和Classes单元
  // 假设YourSynapseUnit包含了TBlockingProcessPool及其相关类的定义
  YourSynapseUnit;

procedure SimulateAsyncCallback(Call: TBlockingProcessPoolCall);
var
  Process: TBlockingProcessPoolItem;
begin
  // 从池中检索与调用标识符匹配的TBlockingProcessPoolItem
  Process := TBlockingProcessPool(Owner).FromCall(Call, True); // 假设Owner是TBlockingProcessPool的引用
  try
    // 在这里模拟异步操作的完成
    // ...

    // 通知等待的进程,异步操作已完成
    Process.NotifyFinished(True); // 由于我们之前已经锁定了Process,所以这里传递True
  finally
    // 如果我们之前没有调用NotifyFinished(True),则需要在这里解锁
    // 但在这个例子中,我们调用了NotifyFinished(True),所以不需要再次解锁
    // Process.Unlock; // 这行是注释掉的,因为不需要在这里解锁
  end;
end;

var
  Pool: TBlockingProcessPool;
  Process: TBlockingProcessPoolItem;
  Call: TBlockingProcessPoolCall;

begin
  try
    // 创建一个TBlockingProcessPool实例
    Pool := TBlockingProcessPool.Create(TBlockingProcessPoolItem);
    try
      // 从池中预订一个新的TBlockingProcessPoolItem
      Process := Pool.NewProcess(5000);
      if Assigned(Process) then
      begin
        // 获取调用标识符(在这个例子中,我们可能不需要直接使用它,但它对于回调是必需的)
        Call := Process.Call;

        // 在这里,您可能会启动一个异步操作,并在其回调中调用SimulateAsyncCallback
        // 但为了演示,我们直接调用SimulateAsyncCallback(尽管这在实际应用中可能是不必要的)
        SimulateAsyncCallback(Call);

        // 注意:在实际应用中,您不会在这里立即调用SimulateAsyncCallback,
        // 因为异步操作将在另一个线程或事件处理器中完成。
        // 在这里,我们只是模拟了异步回调的行为。

        // 由于我们直接模拟了回调,因此不需要再次调用WaitFor。
        // 在实际应用中,您将在启动异步操作后调用Process.WaitFor来等待其完成。

        // 重置TBlockingProcessPoolItem以供重用(如果需要的话)
        // 注意:在大多数情况下,您可能不需要在池中重用项,因为池会管理它们。
        // 但如果您确实需要重置它(例如,在异常情况下),您应该小心处理锁定。
        // 在这个例子中,我们不会重置它,因为池会处理它。

      end;
    finally
      // 销毁TBlockingProcessPool实例
      // 注意:在销毁池时,所有挂起的WaitFor调用都将被强制超时。
      Pool.Free;
    end;
  except
    on E: Exception do
      WriteLn('Error: ' + E.Message);
  end;
end.

注意:在上面的 TBlockingProcessPool示例中,SimulateAsyncCallback过程模拟了异步操作的回调。然而,在实际应用中,回调将由异步操作本身(例如,在另一个线程或事件处理器中)触发,而不是由您直接调用。此外,请注意 Owner的假设,它在这个例子中并未定义,但在实际应用中,您可能需要以某种方式访问 TBlockingProcessPool的实例,以便从回调中检索 TBlockingProcessPoolItem。这通常通过传递池实例的引用或将其存储在可从回调访问的全局/静态变量中来实现。

热门相关:九星毒奶   误踩老公底线:甜心难招架!   北宋大丈夫   驭房之术   我写的书实在太毒了