線程摧毀永遠不會被執行

Question

下載源代碼編譯的可執行文件（221 KB（226925個字節））：前http://www.eyeclaxton.com/download/delphi/skeleton.zip

爲什麼不一樣，如果我關閉應用程序的破壞析構函數被調用（單擊X按鈕）該線程已終止？ FastMM4使用FPauseEvent事件報告內存泄漏。

我應該如何銷燬線程？如果有人在線程結束之前關閉應用程序。

unit SkeletonThread; 

interface 

uses 
    Windows, Classes, SysUtils, SyncObjs; 

type 
    TOnInitialize = procedure(Sender: TObject; const AMaxValue: Integer) of object; 
    TOnBegin = procedure(Sender: TObject) of object; 
    TOnProgress = procedure(Sender: TObject; const APosition: Integer) of object; 
    TOnPause = procedure(Sender: TObject; const APaused: Boolean) of object; 
    TOnFinish = procedure(Sender: TObject) of object; 
    TOnFinalize = procedure(Sender: TObject) of object; 

    TMasterThread = class(TThread) 
    private 
    { Private declarations } 
    FPaused: Boolean; 
    FPosition: Integer; 
    FMaxValue: Integer; 
    FOnBegin: TOnBegin; 
    FOnProgress: TOnProgress; 
    FOnFinish: TOnFinish; 
    FOnInitialize: TOnInitialize; 
    FOnFinalize: TOnFinalize; 
    FPauseEvent: TEvent; 
    FOnPause: TOnPause; 
    procedure BeginEvent(); 
    procedure ProgressEvent(); 
    procedure FinishEvent(); 
    procedure InitializeEvent(); 
    procedure FinalizeEvent(); 
    procedure PauseEvent(); 
    procedure CheckForPause(); 
    protected 
    { Protected declarations } 
    procedure DoInitializeEvent(const AMaxValue: Integer); virtual; 
    procedure DoBeginEvent(); virtual; 
    procedure DoProgress(const APosition: Integer); virtual; 
    procedure DoPauseEvent(const APaused: Boolean); virtual; 
    procedure DoFinishEvent(); virtual; 
    procedure DoFinalizeEvent(); virtual; 
    public 
    { Public declarations } 
    constructor Create(const CreateSuspended: Boolean; const theValue: Integer); 
    destructor Destroy(); override; 
    procedure Pause(); 
    procedure Unpause(); 
    published 
    { Published declarations } 
    property IsPaused: Boolean read FPaused write FPaused default False; 
    property OnInitialize: TOnInitialize read FOnInitialize write FOnInitialize default nil; 
    property OnBegin: TOnBegin read FOnBegin write FOnBegin default nil; 
    property OnProgress: TOnProgress read FOnProgress write FOnProgress default nil; 
    property OnPause: TOnPause read FOnPause write FOnPause default nil; 
    property OnFinish: TOnFinish read FOnFinish write FOnFinish default nil; 
    property OnFinalize: TOnFinalize read FOnFinalize write FOnFinalize default nil; 
    end; 

    TSkeletonThread = class(TMasterThread) 
    private 
    { Private declarations } 
    procedure DoExecute(const theValue: Integer); 
    protected 
    { Protected declarations } 
    procedure Execute(); override; 
    public 
    { Public declarations } 
    published 
    { Published declarations } 
    end; 

implementation 

{ TMasterThread } 
constructor TMasterThread.Create(const CreateSuspended: Boolean; const theValue: Integer); 
begin 
    inherited Create(CreateSuspended); 
    Self.FreeOnTerminate := True; 

    Self.FPosition := 0; 
    Self.FMaxValue := theValue; 
    Self.FPaused := False; 
    Self.FPauseEvent := TEvent.Create(nil, True, True, ''); 
end; 

destructor TMasterThread.Destroy(); 
begin 
    FreeAndNil(FPauseEvent); 
    if (Pointer(FPauseEvent) <> nil) then Pointer(FPauseEvent) := nil; 
    inherited Destroy(); 
end; 

procedure TMasterThread.DoBeginEvent(); 
begin 
    if Assigned(Self.FOnBegin) then Self.FOnBegin(Self); 
end; 

procedure TMasterThread.BeginEvent(); 
begin 
    Self.DoBeginEvent(); 
end; 

procedure TMasterThread.DoProgress(const APosition: Integer); 
begin 
    if Assigned(Self.FOnProgress) then Self.FOnProgress(Self, APosition); 
end; 

procedure TMasterThread.ProgressEvent(); 
begin 
    Self.DoProgress(Self.FPosition); 
end; 

procedure TMasterThread.DoFinishEvent(); 
begin 
    if Assigned(Self.FOnFinish) then Self.FOnFinish(Self); 
end; 

procedure TMasterThread.FinishEvent(); 
begin 
    Self.DoFinishEvent(); 
end; 

procedure TMasterThread.DoInitializeEvent(const AMaxValue: Integer); 
begin 
    if Assigned(Self.FOnInitialize) then Self.FOnInitialize(Self, AMaxValue); 
end; 

procedure TMasterThread.InitializeEvent(); 
begin 
    Self.DoInitializeEvent(Self.FMaxValue); 
end; 

procedure TMasterThread.DoFinalizeEvent(); 
begin 
    if Assigned(Self.FOnFinalize) then Self.FOnFinalize(Self); 
end; 

procedure TMasterThread.FinalizeEvent; 
begin 
    Self.DoFinalizeEvent(); 
end; 

procedure TMasterThread.DoPauseEvent(const APaused: Boolean); 
begin 
    if Assigned(Self.FOnPause) then Self.FOnPause(Self, APaused); 
end; 

procedure TMasterThread.PauseEvent(); 
begin 
    Self.DoPauseEvent(Self.FPaused); 
end; 

procedure TMasterThread.Pause(); 
begin 
    Self.FPauseEvent.ResetEvent(); 
    Self.FPaused := True; 
    Self.Synchronize(Self.PauseEvent); 
end; 

procedure TMasterThread.Unpause(); 
begin 
    Self.FPaused := False; 
    Self.Synchronize(Self.PauseEvent); 
    Self.FPauseEvent.SetEvent(); 
end; 

procedure TMasterThread.CheckForPause(); 
begin 
    if (not (Self.Terminated)) then Windows.Sleep(1); 
    Self.FPauseEvent.WaitFor(INFINITE); 
end; 

{ TSkeletonThread } 
procedure TSkeletonThread.DoExecute(const theValue: Integer); 
var 
    X: Integer; 
begin 
    Self.Synchronize(InitializeEvent); 
    try 
    Self.Synchronize(BeginEvent); 
    try 
     for X := 0 to (theValue - 1) do 
     begin 
    Self.CheckForPause(); 

    if (not Self.FPaused) and (not Self.Terminated) then 
    begin 
     Self.FPosition := Self.FPosition + 1; 
     Self.Synchronize(ProgressEvent); 
    end 
    else begin 
     Break; 
    end; 
     end; 

     for X := Self.FPosition downto 1 do 
     begin 
    Self.CheckForPause(); 

    if (not Self.FPaused) and (not Self.Terminated) then 
    begin 
     Self.FPosition := X; 
     Self.Synchronize(ProgressEvent); 
    end 
    else begin 
     Break; 
    end; 
     end; 
    finally 
     Self.Synchronize(FinishEvent); 
    end; 
    finally 
    Self.Synchronize(FinalizeEvent); 
    end; 
end; 

procedure TSkeletonThread.Execute(); 
begin 
    Self.DoExecute(Self.FMaxValue); 
end; 

end. 

Answer 1

你必須自己終止線程（告訴它停止）。一種方法是使用線程的Terminate過程，但您必須在線程Execute方法中檢查這一點。這樣的事情：

procedure Execute; 
begin 
    inherited; 

    while not Terminated do 
    begin 
    // do your job 
    end; 
end; 

procedure TForm1.StopThread; 
begin 
    MyThread.Terminate; 

    // wait and block until the scheduling thread is finished 
    AResult := WaitForSingleObject(MyThread.Handle, cShutdownTimeout); 

    // check if we timed out 
    if AResult = WAIT_TIMEOUT then 
    TerminateThread(MyThread.Handle, 0); 
end; 

或者你可以使用信號建立到窗口，所以你不必循環。

procedure Execute; 
begin 
    inherited; 

    while not Terminated do 
    begin 
    WaitStatus := WaitForSingleObject(FTermEvent, Max(0, SleepInterval)); 

    // check what was the cause for signalization 
    if WaitStatus <> WAIT_TIMEOUT then 
     Terminate; 
    end; 
end; 

procedure TForm1.StopThread; 
begin 
    // Terminate the thread 
    SetEvent(FTermEvent); 
    // close the handle 
    CloseHandle(FTermEvent); 

    // wait and block until the scheduling thread is finished 
    AResult := WaitForSingleObject(MyThread.Handle, cShutdownTimeout); 

    // check if we timed out 
    if AResult = WAIT_TIMEOUT then 
    TerminateThread(MyThread.Handle, 0); 
end; 

燈號可以終止信令非常簡潔的方式，因爲你可以使用WaitForMultipleObjects的和釋放等待在不同的條件。我使用WaitForSingleObject來使事情不復雜。

另外一定要在線程構造函數中設置「FreeOnTerminate：= True」。哦，當然，最後的硬終端是可選的。這可能是危險的。如果你會使用它，你最瞭解自己。如果您確定線程最終會停止，您還可以等待更長的時間或無限的時間。

Answer 2

像這樣：Starting a process and listening for exit event？