Anonymous threads

Important: as a general rule, you should write your application in a such way that it will behave correctly without EurekaLog on board. This means that if your or 3rd party code throws an exception in a thread - it must be handled in a way that you expect. For example, by showing an error message, canceling action, retrying, etc. Once your application behaves like it is supposed to do - then you add EurekaLog for it. EurekaLog will auto-handle all unhandled exceptions automatically (by hooking few well-known places), and for everything else - you can call EurekaLog from your own handlers when needed. In other words:

Anonymous thread is a wrapper for TThread class which simplifies "fire-and-forget" approach. Creating new threads with bare TThread class is complex: you have to create your own thread class. And TThread is not capable of running arbitrary code, so you can't run just functions in threads. Another advantage of anonymous thread is capturing local variables.

So, for example, such code with TThread class:

type
  TMyThread = class(TThread)
  private
    FLocalVar: TSomeType;
  protected
    procedure Execute; override;
  public
    property LocalVar: TSomeType read FVar write FVar;
  end;
 
procedure TMyMotile.Execute;
begin
  // ... some code which uses LocalVar
end;
 
...
 
var
  Thread: TMyThread;
  LocalVar: TSomeType;
begin
  Thread := TMyMotile.Create(True);
  Thread.LocalVar := LocalVar;
  Thread.FreeOnTerminate := True;
  Thread.Start;
end;

can be replaced with shorter version of the code which uses anonymous thread:

var
  LocalVar: TSomeType;
begin
  TThread.CreateAnonymousThread(
    procedure;
    begin
      // ... some code which uses LocalVar
    end).Start;
end;

Internally, anonymous thread is implemented as TAnonymousThread class which is descendant from TThread class. Instances of TAnonymousThread are created via CreateAnonymousThread class method. The whole code for anonymous threads is very simple:

type
  TAnonymousThread = class(TThread)
  private
    FProc: TProc;
  protected
    procedure Execute; override;
  public
    constructor Create(const AProc: TProc);
  end;
 
{ TAnonymousThread }
 
constructor TAnonymousThread.Create(const AProc: TProc);
begin
  inherited Create(True);
  FreeOnTerminate := True;
  FProc := AProc;
end;
 
procedure TAnonymousThread.Execute;
begin
  FProc();
end;
 
...
 
class function TThread.CreateAnonymousThread(const ThreadProc: TProc): TThread;
begin
  Result := TAnonymousThread.Create(ThreadProc);
end;

Note: anonymous threads are created in suspended state, so you must run them manually with Start method. Suspended state allows you to alter thread's properties or pass additional parameters before running the thread.

Important notes:

TAnonymousThread class have no additional features except being able to accept arbitrary anonymous function to be executed in its Execute method. Since anonymous threads are based on TThread class - the error handling for anonymous thread is the same as for the TThread class - that is, five different methods. Obviously, you can not override DoTerminate method (since you do not declare a class), but all other exception handling methods are fully applicable for anonymous threads.

Important notes:

See also: