mormot.core.threads--TSynBackgroundThreadMethod

海哥  金牌会员 | 2024-7-8 18:50:07 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 891|帖子 891|积分 2673

mormot.core.threads--TSynBackgroundThread

在mORMot 2框架中，TSynBackgroundThreadEvent、TSynBackgroundThreadMethod、TSynBackgroundThreadProcedure、TSynBackgroundThreadProcess和TSynBackgroundTimer这几个类虽然都涉及到背景线程的实行，但它们各自有不同的用途和设计目的。以下是对这些类之间差异的概述：

  • TSynBackgroundThreadEvent：

    • 这个类可能设计用于实行与事件相关的回调函数。它可能封装了一个事件处理机制，答应您在背景线程中响应特定的事件。
    • 回调函数的签名可能包括一个事件发送者（Sender）参数，以及可能的其他参数，用于通报事件相关的数据。
    • 由于名称中包罗“Event”，它可能特殊实用于事件驱动的场景。

  • TSynBackgroundThreadMethod：

    • 这个类设计用于实行标准的TThreadMethod范例的回调，即无参数且返回Void的过程。
    • 它提供了一种在背景线程中实行这些回调的简便方式，使得与Delphi标准线程库兼容的代码可以轻松地与mORMot 2框架集成。
    • 由于TThreadMethod是Delphi中用于线程方法的标准范例，因此这个类可能特殊实用于需要这种兼容性的场景。

  • TSynBackgroundThreadProcedure：

    • 这个类可能设计用于实行简单的无参数过程（procedure）回调，而不是一个对象方法或 TThreadMethod。
    • 它与TSynBackgroundThreadMethod类似，但可能更加专注于那些不需要通报额外参数的过程。
    • 使用这个类可以使代码更加简洁，特殊是当回调不需要访问任何外部状态或参数时。

  • TSynBackgroundThreadProcess：

    • 这个类可能是一个更通用的背景线程处理类，它可能提供了实行周期性使命或长时间运行使命的能力。
    • 它可能封装了线程创建、启动、暂停、恢复和停止的逻辑，以及使命调度的机制。
    • 与其他几个类相比，TSynBackgroundThreadProcess可能更加灵活和强大，实用于需要复杂使命调度的场景。

  • TSynBackgroundTimer：

    • 这个类专门设计用于在背景线程中实行定时使命。
    • 它可能内部维护了一个或多个定时器，答应您安排使命在指定的时间间隔后实行。
    • TSynBackgroundTimer可能还提供了向定时使命通报消息或参数的能力，以及查询使命状态和实行结果的方法。
    • 它特殊实用于需要定时实行使命的场景，如心跳检测、定时轮询等。

上述形貌是基于对类名的一般性推断和假设。现实上，mORMot 2框架中的这些类的具体实现和用途可能有所不同。因此，如果您正在使用mORMot 2框架，而且想要了解这些类简直切差异和用法，最好的做法是查阅mORMot 2的官方文档或源代码。这将为您提供关于这些类的详细信息和示例代码，资助您更好地明白和使用它们。
TSynBackgroundThreadMethodAbstrac 定义
  1. /// TSynBackgroundThreadAbstract 进程的状态机状态
  2. TSynBackgroundThreadProcessStep = (
  3.     flagIdle,           // 空闲状态
  4.     flagStarted,        // 已启动状态
  5.     flagFinished,       // 已完成状态
  6.     flagDestroying);    // 正在销毁状态
  8. /// TSynBackgroundThreadAbstract进程的状态机状态集合
  9. TSynBackgroundThreadProcessSteps = set of TSynBackgroundThreadProcessStep;
  12. /// 抽象TThread类，能够在其自己的执行内容中运行一个方法
  13. // - 典型用途是作为处理数据或远程访问的后台线程，
  14. // 同时UI通过循环运行OnIdle事件保持响应：
  15. // 例如，查看mormot.rest.client.pas单元中TRestClientUri.OnIdle是如何处理此事件的
  16. // - 您不应直接使用此类，而应继承它并重写Process方法，
  17. // 或者使用TSynBackgroundThreadEvent/TSynBackgroundThreadMethod，
  18. // 并提供一个更加方便的回调函数
  19. TSynBackgroundThreadMethodAbstract = class(TSynBackgroundThreadAbstract)
  20. protected
  21.     fPendingProcessLock: TLightLock; // 对fPendingProcessFlag的原子访问
  22.     fCallerEvent: TSynEvent;         // 调用者事件
  23.     fParam: pointer;                 // 参数指针
  24.     fCallerThreadID: TThreadID;      // 调用者线程ID
  25.     fBackgroundException: Exception; // 后台线程异常
  26.     fOnIdle: TOnIdleSynBackgroundThread; // 空闲时回调事件
  27.     fOnBeforeProcess: TOnNotifyThread;    // 处理前通知回调
  28.     fOnAfterProcess: TOnNotifyThread;     // 处理后通知回调
  29.     fPendingProcessFlag: TSynBackgroundThreadProcessStep; // 待处理标志
  30.     procedure ExecuteLoop; override; // 重写执行循环
  31.     function OnIdleProcessNotify(var start: Int64): Int64; // 空闲处理通知，返回已用毫秒数
  32.     function GetOnIdleBackgroundThreadActive: boolean; // 获取OnIdle事件是否激活
  33.     function GetPendingProcess: TSynBackgroundThreadProcessStep; // 获取待处理状态
  34.     procedure SetPendingProcess(State: TSynBackgroundThreadProcessStep); // 设置待处理状态
  35.     // 如果获取成功则返回flagIdle，如果已终止则返回flagDestroying
  36.     function AcquireThread: TSynBackgroundThreadProcessStep;
  37.     procedure WaitForFinished(start: Int64; const onmainthreadidle: TNotifyEvent); // 等待完成
  38.     /// 当fProcessParams<>nil且fEvent被通知时，由Execute方法调用
  39.     procedure Process; virtual; abstract; // 抽象方法，需在子类中实现
  40. public
  41.     /// 初始化线程
  42.     // - 如果aOnIdle未设置（即等于nil），它将简单地等待后台进程完成，直到RunAndWait()返回
  43.     // - 您可以定义一些回调来嵌套线程执行，例如，分配给TRestServer.BeginCurrentThread/EndCurrentThread
  44.     constructor Create(const aOnIdle: TOnIdleSynBackgroundThread;
  45.       const aThreadName: RawUtf8;
  46.       const OnBeforeExecute: TOnNotifyThread = nil;
  47.       const OnAfterExecute: TOnNotifyThread = nil); reintroduce;
  48.     /// 销毁线程
  49.     destructor Destroy; override;
  50.     /// 在后台线程中异步启动Process抽象方法
  51.     // - 等待进程完成，同时调用OnIdle()回调
  52.     // - 在后台线程中引发的任何异常都将在调用者线程中转换
  53.     // - 如果self未设置，或者从当前正在处理的同一线程调用（以避免OnIdle()回调中的竞态条件），则返回false
  54.     // - 当后台进程完成时返回true
  55.     // - OpaqueParam将用于指定后台进程线程安全的内容
  56.     // - 此方法是线程安全的，即它将等待另一个线程已经启动的任何进程：
  57.     // 您可以从任何线程调用此方法，即使其主要用途是从主UI线程调用
  58.     function RunAndWait(OpaqueParam: pointer): boolean;
  59.     /// 设置一个回调事件，在远程阻塞过程期间循环执行，
  60.     // 例如，在长时间请求期间刷新UI
  61.     // - 您可以为此属性分配一个回调，例如调用Application.ProcessMessages，
  62.     // 以在后台线程中执行远程请求，但让UI仍然具有响应性：
  63.     // mORMotUILogin.pas中的TLoginForm.OnIdleProcess和OnIdleProcessForm方法将符合此属性的预期
  64.     // - 如果OnIdle未设置（即等于nil），它将简单地等待后台进程完成，直到RunAndWait()返回
  65.     property OnIdle: TOnIdleSynBackgroundThread   read fOnIdle write fOnIdle;
  66.     /// 如果后台线程处于活动状态，并且在处理过程中调用了OnIdle事件，则为TRUE
  67.     // - 例如，用于确保没有来自用户界面消息的重新进入
  68.     property OnIdleBackgroundThreadActive: boolean read GetOnIdleBackgroundThreadActive;
  69.     /// 在Execute中每次处理之前触发的可选回调事件
  70.     property OnBeforeProcess: TOnNotifyThread   read fOnBeforeProcess write fOnBeforeProcess;
  71.     /// 在Execute中每次处理之后触发的可选回调事件
  72.     property OnAfterProcess: TOnNotifyThread    read fOnAfterProcess write fOnAfterProcess;
  73. end;
复制代码
TSynBackgroundThreadEvent，TSynBackgroundThreadMethod，TSynBackgroundThreadProcedure，TSynBackgroundThreadProcess
TSynBackgroundThreadEvent 定义
  1. /// 由 TSynBackgroundThreadEvent 调用的后台进程方法
  2. // - 当执行Process虚拟方法时，将提供RunAndWait()方法中指定的OpaqueParam参数
  3. TOnProcessSynBackgroundThread = procedure(Sender: TSynBackgroundThreadEvent;
  4.     ProcessOpaqueParam: pointer) of object;
  6. /// 允许后台线程处理方法回调
  7. TSynBackgroundThreadEvent = class(TSynBackgroundThreadMethodAbstract)
  8. protected
  9.     fOnProcess: TOnProcessSynBackgroundThread; // 回调事件
  10.     /// 仅调用OnProcess处理程序
  11.     procedure Process; override; // 重写Process方法
  12. public
  13.     /// 初始化线程
  14.     // - 如果aOnIdle未设置（即等于nil），它将简单地等待后台进程完成，直到RunAndWait()返回
  15.     constructor Create(const aOnProcess: TOnProcessSynBackgroundThread;
  16.       const aOnIdle: TOnIdleSynBackgroundThread;
  17.       const aThreadName: RawUtf8); reintroduce; // 重引入构造函数
  18.     /// 提供一个方法处理程序，在后台线程中执行
  19.     // - 由RunAndWait()方法触发 - 该方法将等待直到完成
  20.     // - 这里将提供RunAndWait()方法中指定的OpaqueParam
  21.     property OnProcess: TOnProcessSynBackgroundThread
  22.       read fOnProcess write fOnProcess; // OnProcess属性，用于访问fOnProcess字段
  23. end;
复制代码
TSynBackgroundThreadMethod 定义
  1. /// 允许后台线程处理可变的TThreadMethod回调
  2. TSynBackgroundThreadMethod = class(TSynBackgroundThreadMethodAbstract)
  3. protected
  4.     /// 仅调用RunAndWait()方法中提供的TThreadMethod
  5.     procedure Process; override; // 重写Process方法
  6. public
  7.     /// 运行一次提供的TThreadMethod回调
  8.     // - 使用此方法，而不是继承的RunAndWait()
  9.     procedure RunAndWait(Method: TThreadMethod); reintroduce; // 重引入RunAndWait方法
  10. end;
复制代码
TSynBackgroundThreadProcedure 定义
  1. /// 由 TSynBackgroundThreadProcedure 调用的后台进程过程
  2. // - 当执行Process虚拟方法时，将提供RunAndWait()方法中指定的OpaqueParam参数
  3. TOnProcessSynBackgroundThreadProc = procedure(ProcessOpaqueParam: pointer);
  5. /// 允许后台线程处理过程回调
  6. TSynBackgroundThreadProcedure = class(TSynBackgroundThreadMethodAbstract)
  7. protected
  8.     fOnProcess: TOnProcessSynBackgroundThreadProc; // 回调过程
  9.     /// 仅调用OnProcess处理程序
  10.     procedure Process; override; // 重写Process方法
  11. public
  12.     /// 初始化线程
  13.     // - 如果aOnIdle未设置（即等于nil），它将简单地等待后台进程完成，直到RunAndWait()返回
  14.     constructor Create(aOnProcess: TOnProcessSynBackgroundThreadProc;
  15.       const aOnIdle: TOnIdleSynBackgroundThread;
  16.       const aThreadName: RawUtf8); reintroduce; // 重引入构造函数
  17.    
  18.     /// 提供一个过程处理程序，在后台线程中执行
  19.     // - 由RunAndWait()方法触发 - 该方法将等待直到完成
  20.     // - 这里将提供RunAndWait()方法中指定的OpaqueParam
  21.     property OnProcess: TOnProcessSynBackgroundThreadProc
  22.       read fOnProcess write fOnProcess; // OnProcess属性，用于访问fOnProcess字段
  23. end;
复制代码
TSynBackgroundThreadProcess 定义
  1. type
  2.   // TSynBackgroundThreadProcess 类声明（稍后定义）
  3.   TSynBackgroundThreadProcess = class;
  5.   /// 由 TSynBackgroundThreadProcess 定期执行的事件回调
  6.   TOnSynBackgroundThreadProcess = procedure(Sender: TSynBackgroundThreadProcess) of object;
  8.   /// 能够以给定周期运行方法的 TThread 类
  9.   TSynBackgroundThreadProcess = class(TSynBackgroundThreadAbstract)
  10.   protected
  11.     fOnProcess: TOnSynBackgroundThreadProcess; // 定期执行的方法回调
  12.     fOnException: TNotifyEvent; // 当 OnProcess 引发异常时执行的事件回调
  13.     fOnProcessMS: cardinal; // 定期执行任务的时间间隔（毫秒）
  14.     fStats: TSynMonitor; // 处理统计信息
  15.     procedure ExecuteLoop; override; // 重写执行循环
  16.   public
  17.     /// 初始化线程以进行周期性任务处理
  18.     // - 当 ProcessEvent.SetEvent 被调用或自上次处理以来过去了 aOnProcessMS 毫秒时，将调用 aOnProcess
  19.     // - 如果 aOnProcessMS 为 0，则等待直到 ProcessEvent.SetEvent 被调用
  20.     // - 您可以定义一些回调来嵌套线程执行，例如，分配给 TRestServer.BeginCurrentThread/EndCurrentThread
  21.     constructor Create(const aThreadName: RawUtf8;
  22.         const aOnProcess: TOnSynBackgroundThreadProcess;
  23.         aOnProcessMS: cardinal;
  24.         const aOnBeforeExecute: TOnNotifyThread = nil;
  25.         const aOnAfterExecute: TOnNotifyThread = nil;
  26.         aStats: TSynMonitorClass = nil;
  27.         CreateSuspended: boolean = false); reintroduce; virtual;
  28.    
  29.     /// 终结线程并等待其结束
  30.     destructor Destroy; override;
  31.    
  32.     /// 访问周期性任务的实现事件
  33.     property OnProcess: TOnSynBackgroundThreadProcess
  34.       read fOnProcess;
  35.    
  36.     /// 当 OnProcess 引发异常时执行的事件回调
  37.     // - 提供的 Sender 参数是引发的异常实例
  38.     property OnException: TNotifyEvent
  39.       read fOnException write fOnException;
  40.   
  41.   published
  42.    
  43.     /// 访问周期性任务处理的延迟时间（毫秒）
  44.     property OnProcessMS: cardinal  read fOnProcessMS write fOnProcessMS;
  45.    
  46.     /// 处理统计信息
  47.     // - 如果在类构造函数中 aStats 为 nil，则可能为 nil
  48.     property Stats: TSynMonitor   read fStats;
  49.   end;
复制代码
TSynBackgroundThreadEvent 例程代码
  1. uses
  2.   SysUtils, Classes, // 引入必要的单元
  3.   mormot.core.threads;
  5. type
  6.   TMyProcessEvent = procedure(Sender: TObject; Param: Pointer) of object;
  8. var
  9.   MyProcessEvent: TMyProcessEvent;
  11. procedure MyBackgroundProcess(Sender: TObject; ProcessOpaqueParam: Pointer);
  12. begin
  13.   // 这里是后台处理的代码
  14.   WriteLn('Background process running with param: ', Pointer(ProcessOpaqueParam)^);
  15.   // 假设我们传递了一个Integer指针作为OpaqueParam
  16.   Integer(ProcessOpaqueParam)^ := Integer(ProcessOpaqueParam)^ + 1;
  17. end;
  19. procedure InitializeAndRunBackgroundThreadEvent;
  20. var
  21.   BGThread: TSynBackgroundThreadEvent;
  22.   Param: PInteger;
  23. begin
  24.   New(Param);
  25.   Param^ := 10; // 初始化参数
  27.   MyProcessEvent := MyBackgroundProcess;
  29.   // 创建并启动后台线程事件
  30.   BGThread := TSynBackgroundThreadEvent.Create(
  31.     MyProcessEvent, // 传递我们的处理过程
  32.     nil, // OnIdle回调，这里不使用
  33.     'MyBackgroundThreadEventDemo'
  34.   );
  35.   try
  36.     // 运行后台线程并等待完成
  37.     BGThread.RunAndWait(Param);
  38.     WriteLn('Background process finished. New param value: ', Param^);
  39.   finally
  40.     BGThread.Free; // 销毁线程对象
  41.     Dispose(Param); // 释放参数内存
  42.   end;
  43. end;
  45. // 在程序的某个地方调用InitializeAndRunBackgroundThreadEvent
复制代码
TSynBackgroundThreadMethod 例程代码
  1. uses
  2.   SysUtils, Classes,
  3.   mormot.core.threads;
  5. procedure MyThreadMethod(Thread: TThread);
  6. begin
  7.   // 这里是线程方法的代码
  8.   WriteLn('Thread method running in background');
  9.   // 模拟一些耗时操作
  10.   Sleep(1000);
  11. end;
  13. procedure RunBackgroundThreadMethod;
  14. var
  15.   BGThread: TSynBackgroundThreadMethod;
  16. begin
  17.   // 创建后台线程方法对象
  18.   BGThread := TSynBackgroundThreadMethod.Create(nil, nil, 'MyBackgroundThreadMethodDemo');
  19.   try
  20.     // 注意：这里我们重写了RunAndWait方法，所以直接传递TThreadMethod
  21.     BGThread.RunAndWait(MyThreadMethod);
  22.   finally
  23.     BGThread.Free; // 销毁线程对象
  24.   end;
  25. end;
  27. // 在程序的某个地方调用RunBackgroundThreadMethod
复制代码
注意：上面的 TSynBackgroundThreadMethod示例中，我假设了 RunAndWait方法被重写以担当 TThreadMethod作为参数，但根据原始定义，这并不是直接支持的。通常，您会在 Process方法内部调用传入的 TThreadMethod。为了保持示例简单，我展示了如何可能使用它，但在现实应用中，您可能需要在 Process方法内部处理这一点。
TSynBackgroundThreadProcedure 例程代码
  1. uses
  2.   SysUtils, Classes,
  3.   mormot.core.threads;
  5. procedure MyBackgroundProcedure(ProcessOpaqueParam: Pointer);
  6. begin
  7.   // 这里是后台过程的代码
  8.   WriteLn('Background procedure running with param: ', Pointer(ProcessOpaqueParam)^);
  9.   // 假设我们传递了一个字符串指针作为OpaqueParam
  10.   WriteLn('String param: ', PString(ProcessOpaqueParam)^);
  11. end;
  13. procedure InitializeAndRunBackgroundThreadProcedure;
  14. var
  15.   BGThread: TSynBackgroundThreadProcedure;
  16.   Param: PString;
  17. begin
  18.   New(Param);
  19.   Param^ := 'Hello, Background!';
  21.   // 创建并启动后台线程过程
  22.   BGThread := TSynBackgroundThreadProcedure.Create(
  23.     MyBackgroundProcedure, // 传递我们的处理过程
  24.     nil, // OnIdle回调，这里不使用
  25.     'MyBackgroundThreadProcedureDemo'
  26.   );
  27.   try
  28.     // 运行后台线程并等待完成
  29.     BGThread.RunAndWait(Param);
  30.   finally
  31.     BGThread.Free; // 销毁线程对象
  32.     Dispose(Param); // 释放参数内存
  33.   end;
  34. end;
  36. // 在程序的某个地方调用InitializeAndRunBackgroundThreadProcedure
复制代码
TSynBackgroundThreadProcess 例程代码
  1. uses
  2.   SysUtils, Classes, // 引入SysUtils和Classes单元以使用WriteLn和TThread等
  3.   mormot.core.threads;
  5. procedure MyProcessMethod(Sender: TSynBackgroundThreadProcess);
  6. begin
  7.   WriteLn('Process method called in background thread.');
  8.   // 在这里执行您的后台处理逻辑
  9. end;
  11. var
  12.   BGThread: TSynBackgroundThreadProcess;
  14. begin
  15.   try
  16.     // 创建TSynBackgroundThreadProcess实例
  17.     BGThread := TSynBackgroundThreadProcess.Create(
  18.       'MyBackgroundThread', // 线程名称
  19.       MyProcessMethod, // 周期性执行的方法
  20.       1000, // 周期时间，单位为毫秒
  21.       nil, // OnBeforeExecute回调，这里不使用
  22.       nil  // OnAfterExecute回调，这里不使用
  23.       // aStats和其他参数根据需要进行设置
  24.     );
  25.     try
  26.       // 启动线程（注意：在TSynBackgroundThreadProcess的构造函数中，
  27.       // 如果CreateSuspended参数为false，则线程将自动启动）
  28.       // 在这个例子中，我们假设CreateSuspended默认为false
  30.       // 等待一段时间以观察后台线程的行为
  31.       // 注意：在实际应用中，您可能不需要这样做，因为主线程可能会继续执行其他任务
  32.       Sleep(5000); // 等待5秒
  34.     finally
  35.       // 销毁线程对象（注意：在析构函数中，线程将尝试优雅地终止）
  36.       BGThread.Free;
  37.       // 等待线程真正结束（可选，但在这个例子中我们依赖析构函数的行为）
  38.     end;
  39.   except
  40.     on E: Exception do
  41.       WriteLn('Error: ' + E.Message);
  42.   end;
  43.   WriteLn('Program ended.');
  44. end.
复制代码
注意：在上面的示例中，我假设TSynBackgroundThreadProcess的构造函数有一个CreateSuspended参数（这在标准的TThread构造函数中是存在的），但根据您提供的类定义，这个参数现实上并没有在TSynBackgroundThreadProcess的构造函数中明确列出。如果TSynBackgroundThreadProcess是自动启动线程的，那么您可能不需要显式调用任何启动方法。
TSynBackgroundTimer 例程代码
  1. uses
  2.   SysUtils, // 引入SysUtils单元以使用WriteLn
  3.   mormot.core.threads;
  5. procedure MyTimerProcess(Sender: TSynBackgroundTimer; const Msg: RawUtf8);
  6. begin
  7.   WriteLn('Timer process called in background thread. Message: ' + Msg);
  8.   // 在这里执行您的定时任务逻辑
  9. end;
  11. var
  12.   Timer: TSynBackgroundTimer;
  14. begin
  15.   try
  16.     // 创建TSynBackgroundTimer实例
  17.     Timer := TSynBackgroundTimer.Create(
  18.       'MyBackgroundTimer' // 线程名称
  19.       // 其他参数根据需要进行设置，这里省略了OnBeforeExecute、OnAfterExecute、aStats和aLogClass
  20.     );
  21.     try
  22.       // 启用一个周期性任务，每2秒执行一次
  23.       Timer.Enable(@MyTimerProcess, 2);
  25.       // 向任务队列添加消息，并请求立即执行（尽管在这个上下文中，立即执行可能不会立即发生）
  26.       Timer.EnQueue(@MyTimerProcess, 'Hello from background timer!', true);
  28.       // 等待一段时间以观察后台定时器的行为
  29.       // 注意：在实际应用中，您可能不需要这样做，因为主线程可能会继续执行其他任务
  30.       Sleep(10000); // 等待10秒
  32.       // 禁用周期性任务（在这个示例中我们不会禁用它，但展示了如何禁用）
  33.       // Timer.Disable(@MyTimerProcess);
  35.     finally
  36.       // 销毁TSynBackgroundTimer实例（注意：在实际应用中，您可能希望等待所有后台任务完成后再销毁定时器）
  37.       // 但在这个简单示例中，我们立即销毁它
  38.       Timer.Free;
  39.       // 由于我们立即销毁了定时器，并且主线程继续执行（尽管在这个示例中被Sleep阻塞了），
  40.       // 因此后台线程可能没有机会执行更多的回调。
  41.       // 在实际应用中，您应该确保在销毁定时器之前给后台线程足够的时间来完成其工作。
  42.     end;
  43.   except
  44.     on E: Exception do
  45.       WriteLn('Error: ' + E.Message);
  46.   end;
  47.   WriteLn('Program ended.');
  48. end.
复制代码
在上面的TSynBackgroundTimer示例中，我展示了如何创建定时器、启用周期性使命、向使命队列添加消息，并等待一段时间以观察定时器的行为。请注意，由于我们调用了Sleep而且立即烧毁了定时器，因此背景线程可能没有机会实行更多的回调。在现实应用中，您应该确保在烧毁定时器之前给背景线程足够的时间来完成其工作，或者调用Timer.WaitUntilNotProcessing（如果该类提供了这样的方法）来等待所有背景使命完成。然而，根据提供的类定义，TSynBackgroundTimer并没有直接提供WaitUntilNotProcessing方法，所以您可能需要实现自己的同步机制来到达这个目的。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

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

本版积分规则

海哥

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

楼主热帖

标签云

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