Delphi: how to deal with dynamically created threads

Question

I have a child from TThread. Everything works fine, but how can I do a mass suspend or resume of my created threads? Or how can I suspend only a second thread (which was created in Button2Click)? Here is a part of my code:

TMyThread = class(TThread)
private
  source_file, destination_file: string;
  total_size, current_size, download_item_id: integer;
protected
  procedure ShowResult;
  procedure Execute; override;
public
end;

var
 MyThread: TMyThread;

begin

procedure TMyThread.Execute;
 begin
  //Some code for download file here, it doesn't matter
 end;


procedure TForm1.Button1Click(Sender: TObject);
begin
  MyThread := TMyThread.Create(True);
  MyThread.source_file :='http://example.com/download1.zip';
  MyThread.destination_file := 'c:\download1.zip';
  MyThread.download_item_id := 0;
  MyThread.Priority := tpNormal;
  MyThread.FreeOnTerminate := True;
  MyThread.Resume;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  MyThread := TMyThread.Create(True);
  MyThread.source_file :='http://example.com/download2.zip';
  MyThread.destination_file := 'c:\download2.zip';
  MyThread.download_item_id := 1;
  MyThread.Priority := tpNormal;
  MyThread.FreeOnTerminate := True;
  MyThread.Resume;
end;

end.

That is, if I create a threads like this - it's works for me:

var
 MyThread1, MyThread2: TMyThread;
...
procedure TForm1.Button1Click(Sender: TObject);
begin
  MyThread1 := TMyThread.Create(True);
  MyThread1.source_file :='http://example.com/download1.zip';
  MyThread1.destination_file := 'c:\download1.zip';
  MyThread1.download_item_id := 0;
  MyThread1.Priority := tpNormal;
  MyThread1.FreeOnTerminate := True;
  MyThread1.Resume;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  MyThread2 := TMyThread.Create(True);
  MyThread2.source_file :='http://example.com/download2.zip';
  MyThread2.destination_file := 'c:\download2.zip';
  MyThread2.download_item_id := 1;
  MyThread2.Priority := tpNormal;
  MyThread2.FreeOnTerminate := True;
  MyThread2.Resume;
end;

//Terminate all of TMyThread
procedure TForm1.Button3Click(Sender: TObject);
begin
  MyThread1.Terminate;
  MyThread2.Terminate;
  ShowMessage('All downloads were terminated!');
end;

//Terminate ONLY the second of TMyThread
procedure TForm1.Button4Click(Sender: TObject);
begin
  MyThread2.Terminate;
  ShowMessage('The second download was terminated!');
end;

But how to do it for a set of dynamically created TMyThread (as in the first code sample)?

Answer 1

Limitation

You really, really shouldn't keep references to threads that are set to free on termination. It is asking for all sorts of problems. The code below does use threads with FreeOnTerminate set to True. This is only safe because: 1) the references are removed as the thread terminates and before it is freed; 2) The OnTerminate handler is called in the context of the mainthread and/or a thread safe TList descendant is used; and - most importantly - 3) the references are only used to cancel threads selectively from within the context of the main thread.

As soon as you want to use the references for anything else (like pausing and resuming) or could access them from within the context of any thread other than the main thread, you really should delve a lot deeper into various mechanisms of threaded program execution.

A couple of keywords: thread synchronization, event signalling, mutex's, semaphores, critical sections.

A good reference to multi-threaded programming with Delphi is Multithreading - The Delphi Way

Answer

If you really need to reference the threads later on, you do need to store your references somewhere. But you do not need to have separate variables for each thread you create. There are many options. An array comes to mind, but probably the simplest is an object list (from the Contnrs unit):

TForm1 = class(TForm)
  private
    MyThreads: TObjectList;

constructor TForm1.Create(AOwner: TComponent);
begin
  inherited;
  MyThreads := TObjectList.Create;
end;

destructor TForm1.Destroy;
begin
  MyThreads.Free;
  inherited;
end;

TObjectList has an OwnsObjects property which by default is True. This means that freeing the object list will also free the instances it contains. And this means that you need to ensure that the list only contains valid references. Normally that is not a problem, but with threads you need to take special care, especially when you use FreeOnTerminate set to True.

Create your threads like you do in your first example, with a couple of changes:

Use a local variable (you should avoid global variables, even if they are only visible within the unit as much as possible).

Add the thread to your object list.

Set an OnTerminate handler to remove the instance from your object list when you also want to use 'FreeOnTerminate` set to True.

procedure TForm1.Button1Click(Sender: TObject);
var
  Thread: TThread;                                       // Local var
begin
  Thread := TMyThread.Create(True);
  MyThreads.Add(Thread);                                 // Add to list
  Thread.source_file :='http://example.com/download1.zip';
  Thread.destination_file := 'c:\download1.zip';
  Thread.download_item_id := 0;
  Thread.Priority := tpNormal;
  Thread.OnTerminate := HandleThreadTerminate;           // Ensure you keep list valid
  Thread.FreeOnTerminate := True;                        // Advice against this!
  Thread.Start;
end;

procedure TForm1.HandleThreadTerminate(Sender: TObject);
var
  idx: Integer;
begin
  // Acquire Lock to protect list access from two threads
  idx := MyThreads.IndexOf(Sender);
  if idx > -1 then
    MyThreads.Delete(idx);
  // Release lock
end;

The HandleThreadTerminate procedure should use some kind of lock, so two threads cannot at the same time try to delete instances from the list as a thread switch between IndexOf and Delete could mean deleting the wrong instance. The code in the handler could be written as MyThreads.Remove(Sender). Although that is a single statement, it isn't thread safe as it does the same as the code I've shown behind the scenes.

Edit: Actually, as @LURD mentions it happens to be thread safe because OnTerminate is called in the context of the main thread. I am leaving the TThreadList example because it is a good way to do things if you need / happen to access the list from multiple threads.

To have the locking stuff taken care of automatically, you can use a TThreadList (from the classes unit). Required code changes:

Of course you need to instantiate a TThreadList instead of a TObjectList.

constructor TForm1.Create(AOwner: TComponent);
begin
  inherited;
  MyThreads := TThreadList.Create;
end;

Because TThreadList has no concept of OwnsObjects, you will have to free any remaining threads yourself:

destructor TForm1.Destroy;
var
  LockedList: TList;
  idx: integer;
begin
  LockedList := MyThreads.LockList;
  try
    for idx := LockedList.Count - 1 downto 0 do
      TObject(MyThreads.Items(idx)).Free;
  finally
    MyThreads.UnlockList;
  end;

  MyThreads.Free;
  inherited;
end;

The OnTerminate handler can now safely be simplified as the TThreadList will take care of the required locking.

procedure TForm1.HandleThreadTerminate(Sender: TObject);
begin
  MyThreads.Remove(idx);
end;

Edit: As @mghie mentions, freeing a thread when FreeOnTerminate is true clashes with the whole idea of free on terminate. You can either set FreeOnTerminate to false before you free the thread (which would terminate it), or if you want to keep the FreeOnTerminate handling, you should disconnect the OnTerminate handler and then use Terminate to tell the thread to terminate.

destructor TForm1.Destroy;
var
  LockedList: TList;
  idx: integer;
begin
  LockedList := MyThreads.LockList;
  try
    for idx := LockedList.Count - 1 downto 0 do
    begin
      TThread(MyThreads.Items(idx)).OnTerminate := nil;
      TThread(MyThreads.Items(idx)).Terminate;
    end;
  finally
    MyThreads.UnlockList;
  end;

  MyThreads.Free;
  inherited;
end;

Answer 2

The answer is really simple - if you create a FreeOnTerminate type TThread then you do not utilize any outside references at all to that TThread instance. To do so is like playing Russian Roulette...it will blow up in your face sooner or later. Yes, there are some ways to do it, but you just shouldn't.

What you can do is to introduce a shared communication medium between the parent and child. There are many different ways of communicating status updates from the child thread that do not involve any direct reference to the TThread instance. (Check out custom windows messages, the likely most used method.)

A really obvious (I think), simplistic example. I am coding this inside this message box so don't expect it to compile... This is just to help demonstrate that a separate mechanism is required that needs to be configured so you can safely communicate between the parent and child without relying on a reference to some TThread instance. (This assumes one child thread...and yes, there are many other ways of doing this.)

unit MyPubComm.pas;

initialization
uses ...;

type
  TThreadComm = class
  private
    fThreadIsBusy:Boolean;  //more likely a State of some sort
    fThreadMessage:String;
  public
   property ThreadIsBusy:Boolean read fThreadIsBusy write fThreadIsBusy;
   property ThreadMessage:String read fThreadMessage write fThreadMessage;
  end;

  function IsChildBusy:Boolean;
  function ChildMessage:String;
  procedure SetThreadMessage(const MessageText:String);

var
  pubThreadStatus:TThreadComm;


implementation

function IsChildBusy:Boolean;
begin
  pubThreadStatus.Monitor.Enter;
  try
    Result := pubThreadStatus.ThreadIsBusy;
  finally
    pubThreadStatus.Monitor.Exit;
  end;
end;

function ChildMessage:String;
begin
  pubThreadStatus.Monitor.Enter;
  try
    Result := pubThreadStatus.ThreadMessage;
  finally
    pubThreadStatus.Monitor.Exit;
  end;
end;

procedure SetThreadMessage(const MessageText:String);
begin
  pubThreadStatus.Monitor.Enter;
  try
    pubThreadStatus.ThreadMessage := MessageText;
  finally
    pubThreadStatus.Monitor.Exit;
  end;
end;


initialization
  pubThreadStatus := TThreadCom.Create;
finalization
  pubThreadStatus.Free();

--------
unit MainAppCode.pas
...
implementation
Uses MyPubComm;

procedure TMyForm1.WorkingOnSomething();
begin
   if IsChildBusy() then  //safely check child state
   begin 
      label1.caption := 'Child thread busy...';
   end
   else
   begin
      label1.caption := ChildMessage();  //safely retrieve shared data
   end;
end;
------
MyThread.pas
...
implementation
Uses MyPubComm;

function TMyThread.WorkerBee();
begin
   If TimeToCommunicateThreadMessage then
   begin 
     SetThreadMessage(MyMessage);  //safely update shared data
   end;
end;

This also should show an obvious problem in WorkingOnSomething() Between the time of the check IsChildBusy() and the ChildMessage() call, the actual busy state and message text could change which is why a much more robust communication method is required.