Correct thread terminate and destroy

http://www.techques.com/question/1-3788743/Correct-thread-destroy

Hello At my form I create TFrame at runtime.

At this frame I create background thread with executes commands in endless loop.

But when I destroy this frame I should destroy this thread. I try

thread.Suspend;
thread.Terminate;
FreeAndNil(thread);

but get AV and ThreadError. How should i destroy thread?

Don't suspend the thread. The terminate method just set the Terminated property to true,

and your Execute method is responsible to terminate the thread.

If it is suspended, it will not get a chance to terminate.

Another problem with the code above, is that it likely frees the thread

before it has a change to terminate the normal way.

You must make sure that thread exits it's execute method to terminate it properly.

Code could be something like this:

procedure TThread.Execute;
begin
  while not Self.Terminated do
  begin
    //do something
  end;
end;

Call this when You want to destroy thread:

thread.Terminate;
thread.WaitFor;
FreeAndNil(thread);

It's not necessary to call `Terminate` and `WaitFor` from the outside,

as the thread destructor will do it itself.

It may be necessary though to call it from overwritten destructors,

before any fields are freed, to make sure these are no longer used from the thread.

It is sufficient to do thread.Terminate.

But you will probably want to set thread.FreeOnTerminate := true when it is created.

Of course, in the tight loop of your thread (that is, in Execute),

you need to check if the thread has been requested to terminate

(check the Terminated property).

If you find that the thread has been requested to terminate,

simply break from the loop and exit from Execute.

thread.Terminate only sets FTerminated property to True. It doesn't destroy thread.

I know. But every thread must check for that in its Execute method.

I assume the OP is doing this.

You should never call suspend on a tthread its not safe to do so and resume should only be used to start a thread that was created suspended.

In Delphi 2010 the suspend and resume where depreciated and the method start was introduced to reinforce this.

For a more complete explanation see this thread at Codegears forums.

having said that there are 2 ways I will terminate and free a tthread.

1: I Set FreeOnTerminate when the thread is created so I just call.

Thread.Terminate;

2: Free the thread explicitly, as I need to read a result from a public property before the thread is freed and after it has terminated.

Thread.Terminate;
Thread.WaitFor;
//Do somthing like read a public property from thread object
if Thread <> nil then FreeAndNil(Thread);

In the main execute loop it may be a good idea to put some exception handling in.

Or you may be left wondering why the thread appears to terminate its self.

This may be causing the AV if the thread is set to FreeOnTerminate and it has already been freed when you try to free it.

procedure TThread.Execute;
begin
  while not Terminated do
  begin
    try
      //do something
    except
      on E:Exception do
       //handle the exception
    end;
  end;
end; 

Free a TThread either automatically or manually

I have a main thread and a separate thread in my program.

If the separate thread finishes before the main thread, it should free itself automatically.

If the main thread finishes first, it should free the separate thread.

I know about FreeOnTerminate, and I've read that you have to be careful using it.

My question is, is the following code correct?

procedure TMyThread.Execute;
begin
  ... Do some processing

  Synchronize(ThreadFinished);

  if Terminated then exit;

  FreeOnTerminate := true;
end;

procedure TMyThread.ThreadFinished;
begin
  MainForm.MyThreadReady := true;
end;

procedure TMainForm.Create;
begin
  MyThreadReady := false;

  MyThread := TMyThread.Create(false);
end;

procedure TMainForm.Close;
begin
  if not MyThreadReady then
  begin
    MyThread.Terminate;
    MyThread.WaitFor;
    MyThread.Free;
  end;
end;

Thanks!

You can simplify this to:

procedure TMyThread.Execute;
begin
  // ... Do some processing
end;

procedure TMainForm.Create;
begin
  MyThread := TMyThread.Create(false);
end;

procedure TMainForm.Close;
begin
  if Assigned(MyThread) then
    MyThread.Terminate;
  MyThread.Free;
end;

Explanation:

• Either use FreeOnTerminate or free the thread manually, but never do both.
  The asynchronous nature of the thread execution means that you run a risk of not freeing the thread
  or (much worse) doing it twice.

  There is no risk in keeping the thread object around after it has finished the execution,
  and there is no risk in calling Terminate() on a thread that has already finished either.

• There is no need to synchronize access to a boolean that is only written from one thread and read from another.
  In the worst case you get the wrong value, but due to the asynchronous execution that is a spurious effect anyway.
  Synchronization is only necessary for data that can not be read or written to atomi

How to terminate anonymous threads in Delphi on application close?

http://www.techques.com/question/1-10401865/How-to-terminate-anonymous-threads-in-Delphi-on-application-close

I have a Delphi application which spawns 6 anonymous threads upon some TTimer.OnTimer event.

If I close the application from the X button in titlebar Access Violation at address $C0000005 is raised and FastMM reports leaked TAnonymousThread objects.

Which is the best way to free anonymous threads in Delphi created within OnTimer event with TThread.CreateAnonymousThread() method?

SOLUTION which worked for me:

Created a wrapper of the anonymous threads which terminates them upon being Free-ed.

type
  TAnonumousThreadPool = class sealed(TObject)
  strict private
    FThreadList: TThreadList;
    procedure TerminateRunningThreads;
    procedure AnonumousThreadTerminate(Sender: TObject);
  public
    destructor Destroy; override; final;
    procedure Start(const Procs: array of TProc);
  end;

{ TAnonumousThreadPool }

procedure TAnonumousThreadPool.Start(const Procs: array of TProc);
var
  T: TThread;
  n: Integer;
begin
  TerminateRunningThreads;

  FThreadList := TThreadList.Create;
  FThreadList.Duplicates := TDuplicates.dupError;

  for n := Low(Procs) to High(Procs) do
  begin
    T := TThread.CreateAnonymousThread(Procs[n]);
    TThread.NameThreadForDebugging(AnsiString('Test thread N:' + IntToStr(n) + ' TID:'), T.ThreadID);
    T.OnTerminate := AnonumousThreadTerminate;
    T.FreeOnTerminate := true;
    FThreadList.LockList;
    try
      FThreadList.Add(T);
    finally
      FThreadList.UnlockList;
    end;
    T.Start;
  end;
end;

procedure TAnonumousThreadPool.AnonumousThreadTerminate(Sender: TObject);
begin
  FThreadList.LockList;
  try
    FThreadList.Remove((Sender as TThread));
  finally
    FThreadList.UnlockList;
  end;
end;

procedure TAnonumousThreadPool.TerminateRunningThreads;
var
  L: TList;
  T: TThread;
begin
  if not Assigned(FThreadList) then
    Exit;
  L := FThreadList.LockList;
  try
    while L.Count >  do
    begin
      T := TThread(L[]);
      T.OnTerminate := nil;
      L.Remove(L[]);
      T.FreeOnTerminate := False;
      T.Terminate;
      T.Free;
    end;
  finally
    FThreadList.UnlockList;
  end;
  FThreadList.Free;
end;

destructor TAnonumousThreadPool.Destroy;
begin
  TerminateRunningThreads;
  inherited;
end;

End here is how you can call it:

procedure TForm1.Button1Click(Sender: TObject);
begin
  FAnonymousThreadPool.Start([ // array of procedures to execute
    procedure{anonymous1}()
    var
      Http: THttpClient;
    begin
      Http := THttpClient.Create;
      try
        Http.CancelledCallback := function: Boolean
          begin
            Result := TThread.CurrentThread.CheckTerminated;
          end;
        Http.GetFile('http://mtgstudio.com/Screenshots/shot1.png', 'c:\1.jpg');
      finally
        Http.Free;
      end;
    end,

    procedure{anonymous2}()
    var
      Http: THttpClient;
    begin
      Http := THttpClient.Create;
      try
        Http.CancelledCallback := function: Boolean
          begin
            Result := TThread.CurrentThread.CheckTerminated;
          end;
        Http.GetFile('http://mtgstudio.com/Screenshots/shot2.png', 'c:\2.jpg');
      finally
        Http.Free;
      end;
    end
  ]);
end;

No memory leaks, proper shutdown and easy to use.

If you want to maintain and exert control over your threads' lifetimes then you should not use anonymous threads.

Maintain a list of TThread instances and free them at shutdown time.

Whilst it is possible to do what you want with anonymous threads,

it's a lot of extra work that brings no real benefits.

I see.

But I still do not get it.

TAnonymousThread is a descendant of TThread.

So I can maintain a list of them and try to terminate them (since the RTL does not do it automatically).

When I try to terminate it says:

Project mtgstudio.exe raised exception class EThread with message 'Thread Error: The handle is invalid (6)'.

Read the docs for the anonymous thread.

You are not allowed to hold a reference to the TThread since it uses FreeOnTerminate.

System.Classes.TThread.CreateAnonymousThread

Creates an instance of an internally derived thread.

CreateAnonymousThread creates an instance of an internally derived TThread that simply will call the anonymous method of typeTProc.

This thread is created as suspended, so you should call the Start method to make the thread run.

The thread is also marked as FreeOnTerminate, so you should not touch the returned instance after calling Start.

It is possible that the instance had run and then has been freed before other external calls or operations on the instance were attempted.

type TProc = reference to procedure;
type TProc = reference to procedure(Arg1: T);
type TProc = reference to procedure(Arg1: T1, Arg2: T2);
type TProc = reference to procedure(Arg1: T1, Arg2: T2, Arg3: T3);
type TProc = reference to procedure(Arg1: T1, Arg2: T2, Arg3: T3, Arg4: T4);

TProc declares a reference to a generic procedure.

Use the TProc type as a reference to a generic procedure.

There are a few variants of TProc type, each accepting a different number of generic arguments.