如何无错误无延迟终止处于等待状态的线程？

一、核心问题解决：打破Get方法的阻塞等待 #

线程终止延迟的根源是TBlockingQueue<T>.Get方法在等待时无法响应线程的Terminated信号。要解决这个问题，需要修改TBlockingQueue<T>类，添加主动唤醒机制，让线程终止时能立即结束等待。

修改TBlockingQueue<T>类 #

新增终止标记和唤醒方法，修改Get逻辑使其能响应终止信号：

Type
  TBlockingQueue<T> = Class
  Strict Protected
    FGuard     : {$IFDEF FPC}TRTLCriticalSection{$ELSE}TCriticalSection{$ENDIF};
    FCondition : TConditionVariableCS;
    FQueue     : TQueue<T>;
    FTerminated: Boolean; // 新增终止标记
  Public
    Function Count: Integer; Virtual;
    Function Get(ATimeOut: LongWord): T; Virtual;
    Procedure Put( Item: T ); Virtual;
    Procedure Terminate; Virtual; // 新增终止唤醒方法
    Constructor Create; Virtual;
    Destructor Destroy; Override;
  End;

实现新增方法并调整Get逻辑：

procedure TBlockingQueue<T>.Terminate;
begin
  {$IFDEF FPC}
  EnterCriticalSection(FGuard);
  {$ELSE}
  FGuard.Acquire;
  {$ENDIF}
  try
    FTerminated := True;
    FCondition.ReleaseAll; // 唤醒所有等待的线程
  finally
    {$IFDEF FPC}
     LeaveCriticalSection(FGuard);
    {$ELSE}
    FGuard.Release;
    {$ENDIF}
  end;
end;

function TBlockingQueue<T>.Get(ATimeOut: LongWord): T;
begin
  {$IFDEF FPC}
  EnterCriticalSection(FGuard);
  {$ELSE}
  FGuard.Acquire;
  {$ENDIF}
  try
    // 同时检查队列是否为空、是否已终止
    while (FQueue.Count = 0) and not FTerminated do
    begin
     {$IFDEF FPC}
      if FCondition.WaitForRTL(FGuard, ATimeOut) = wrTimeout then
     {$Else}
      if FCondition.WaitFor(FGuard, ATimeOut) = wrTimeout then
     {$EndIf}
       raise AMQPTimeout.Create('Timeout!');
    end;
    
    // 终止时返回默认值（引用类型为nil）
    if FTerminated then
      Result := Default(T)
    else
      Result := FQueue.Dequeue;
  finally
  {$IFDEF FPC}
   LeaveCriticalSection(FGuard);
  {$ELSE}
  FGuard.Release;
  {$ENDIF}
  end;
end;

二、调整线程代码，响应终止信号 #

1. 修改TerminatedSet方法，通知队列终止 #

将lMsgQueue从Execute局部变量改为线程类成员变量，在TerminatedSet中主动触发队列终止，打破Get的阻塞：

procedure TConsumerThread.TerminatedSet;
begin
  inherited;
  // 先通知队列终止，立即唤醒等待的Get调用
  if Assigned(lMsgQueue) then
    lMsgQueue.Terminate;
  
  if Assigned(FChannelAMQPThread) then
  begin
    try
      if FConnectionAMQP.IsOpen then
        FConnectionAMQP.CloseChannel(FChannelAMQPThread);
    except
      on E: Exception do; // 忽略关闭异常，避免终止流程卡住
    end;
    FChannelAMQPThread := nil;
  end;
end;

2. 优化Execute方法逻辑 #

在Get调用后优先检查线程终止状态，避免无效操作：

procedure TConsumerThread.Execute;
var
  lMsg: TAMQPMessage;
  lStartTime: TDateTime;
begin
  lMsgQueue := TAMQPMessageQueue.Create;
  try
    FChannelAMQPThread := FConnectionAMQP.OpenChannel(FQueuePrefetchSize, FQueuePrefetchCount);
    try
      FChannelAMQPThread.BasicConsume(lMsgQueue, FQueue, 'Consumer');
      lStartTime := Now;
      repeat
        try
          // 原有连接检查逻辑...
          if not(FConnectionAMQP.IsOpen) then
          BEGIN
            FConnectionAMQP.Connect;
            FChannelAMQPThread := FConnectionAMQP.OpenChannel(FQueuePrefetchSize, FQueuePrefetchCount);
            FChannelAMQPThread.BasicConsume(lMsgQueue, FQueue, 'Consumer');
          END;

          lMsg := lMsgQueue.Get(FQueueGetTimeout);
          
          // 优先检查线程是否终止，直接退出循环
          if Terminated then
            Break;

          // 后续消息处理逻辑...
          if ValidateFilter(lMsg) then
          begin
            FCorrelationID := lMsg.Header.PropertyList.CorrelationID.Value;
            FReceivedMessage := lMsg.Body.asString[TEncoding.ASCII];
            lMsg.Ack;
            lMsg.Free;
            Terminate;
          end
          else
          begin
            lMsg.Reject;
            lMsg.Free;
            if not(FTimeout = INFINITE) then
            begin
              if (MilliSecondsBetween(Now, lStartTime) >= (Int64(FTimeout))) then
              begin
                FReceivedMessage := '';
                Terminate;
              end;
            end;
          end;
        except
          on E: AMQPTimeout do
          begin
            if Terminated then Break;
            // 原有超时重连逻辑...
            if Assigned(FChannelAMQPThread) then
            begin
              FConnectionAMQP.CloseChannel(FChannelAMQPThread);
              FChannelAMQPThread := nil;
            end;
            FChannelAMQPThread := FConnectionAMQP.OpenChannel(FQueuePrefetchSize, FQueuePrefetchCount);
            FChannelAMQPThread.BasicConsume(lMsgQueue, FQueue, 'Consumer');
          end;
          on E: Exception do
          begin
            if Assigned(lMsg) then
            begin
              lMsg.Free;
              lMsg := nil;
            end;
            if Terminated then Break;
          end;
        end;
      until Terminated;
    except
      on E: Exception do
      begin
        FReceivedMessage := '';
        if not Terminated then
          Terminate;
      end;
    end;
  finally
    lMsgQueue.Free;
  end;
end;

三、关于FreeOnTerminate和挂起启动的问题 #

1. FreeOnTerminate := True的合理性：
   你的场景中使用该设置是最优选择，因为你通过OnTerminate处理线程结束后的逻辑，自动释放线程对象能避免内存泄漏。注意：必须在所有属性设置完成后调用Resume启动线程，避免线程未初始化完成就被释放。

2. 挂起启动的方式：
   通过inherited Create(True)挂起创建线程、再设置属性的方式是安全的，这是Delphi中初始化线程属性的标准做法，能避免线程在属性未配置完成时就执行Execute逻辑。

内容的提问来源于stack exchange，提问作者missingNO