问当一个控件被销毁时，我应该何时停止我的线程(TCustomControl后代)

EN

if not (csDestroying in ComponentState) then

unit VclMutex;

interface uses Windows, Messages, SysUtils;

const
  WM_WaitInMainThread = WM_USER + 1;

type
  TVCLMutex = class
  private
    fVCLWaitEvent: THandle;
    fAccessAvailEvent: THandle;
    fWnd: HWnd;
    fThreadId: Cardinal;
    fLevel: integer;
  protected
    procedure   WndProc(var Msg: TMessage);
  public
    constructor Create;
    destructor  Destroy;override;
    procedure   Access;
    procedure   Release;
  end;

implementation uses Forms;

{ TVCLMutex }

constructor TVCLMutex.Create;
begin
  inherited Create;

  if GetCurrentThreadId <> MainThreadId then
    raise Exception.Create('The object should be created in the main thread');

  fWnd:=AllocateHWnd(WndProc);
  fVCLWaitEvent:=CreateEvent(Nil, false, false, Nil);
  fAccessAvailEvent:=CreateEvent(Nil, false, true, Nil); 
end;

destructor TVCLMutex.Destroy;
begin
  CloseHandle(fVCLWaitEvent);   
  CloseHandle(fAccessAvailEvent);

  DeallocateHWnd(fWnd);
  inherited;
end;

procedure TVCLMutex.WndProc(var Msg: TMessage);
begin
  case Msg.Msg of
    WM_WaitInMainThread:
      begin
           { ReplyMessage make return from SendMessage call called from other thread }
        ReplyMessage(0);

           { Waiting to release VCL (main thread) queure. Signal will come from the
             Release method of working thread  }
        WaitForSingleObject(fVCLWaitEvent, INFINITE);
      end
    else
      Msg.Result := DefWindowProc(FWnd, Msg.Msg, Msg.wParam, Msg.lParam);
  end;
end;

procedure TVCLMutex.Access;
var
  AThreadId: Cardinal;
begin
  AThreadId:=GetCurrentThreadId();

  if GetCurrentThreadId = fThreadId then
  begin
      { If owning thread then allow while keeping nested level }
    Inc(fLevel);
  end
  else
  begin
       { Waiting for section to be available (from other threads) }
    WaitForSingleObject(fAccessAvailEvent, INFINITE);

       { Owning thread }
    fThreadId:=AThreadId;

       { Ask main thread queue to wait }
    if fThreadId <> MainThreadId then
      SendMessage(fWnd, WM_WaitInMainThread, 0, 0);

    fLevel:=1;
  end
end;

procedure TVCLMutex.Release;
begin
  Dec(fLevel);

  if fLevel = 0 then { All nested releases passed  }
  begin
        { Signaling for queue to release (if different thread) }
    if fThreadId <> MainThreadId then
      SetEvent(fVCLWaitEvent);

    fThreadId:=0;
       { Signaling that the mutex section is available }
    SetEvent(fAccessAvailEvent);
  end;
end;

end.