Thread Startup Speed in Delphi - multithreading

Question

I am not sure that this question exclusively pertains to Delphi but that is what I use, so I will refer to that.
I have been told that starting up a new thread, even from a typically implemented threadpool takes about 20 - 40ms. I was referred to the article at https://learn.microsoft.com/en-us/windows/desktop/procthread/multitasking, which basically says that a timeslice in Windows is about 20 ms, so realistically the minimum thread execution time is 20 ms.
I have written the code below, which is very basic. In a VMWare workstation VM that is set up with 2 processors, 1 core per processor, the timing reports about 17 ms to complete.
When I run it on my host machine, (an i7-6700) the stopwatch consistently reports 0 ms to complete. I was told that I am just getting "lucky" with the WaitFor on my host machine, and that typically I should expect 20 ms for a single thread. Obviously this means that trying to lower the time of threaded execution below 20ms is not possible.
Is there any definitive explanation about how quickly it takes to start a thread?
The code I am using for testing is below.
unit Unit1;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
Memo1: TMemo;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
TMyThread=class(TThread)
public
Sum:integer;
procedure Execute;override;
end;
var
Form1: TForm1;
implementation
uses
System.Diagnostics;
{$R *.dfm}
procedure TForm1.Button1Click(Sender: TObject);
var
sw:TStopWatch;
thrd: TMyThread;
theSum:integer;
begin
sw:=TStopWatch.StartNew;
thrd:=TMyThread.Create;
thrd.WaitFor;
theSum:=thrd.sum;
thrd.Free;
sw.Stop;
memo1.lines.add('sum: '+theSum.ToString);
memo1.lines.add('elapsed: '+sw.ElapsedMilliseconds.toString);
end;
{ TMyThread }
procedure TMyThread.Execute;
var
cntr: Integer;
begin
inherited;
sum:=0;
for cntr := 0 to 100 do
sum:=sum+cntr;
end;
end.

Answer 1

The fastest speed I was able to get is 14-16 ms with the following code on Win10 x64, i5 6500, Delphi Rio:
unit Unit1;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
Label1: TLabel;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
TMyThread = class(TThread)
public
procedure Execute; override;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.Button1Click(Sender: TObject);
var
M: TMyThread;
S, L: Int64;
begin
QueryPerformanceCounter(S);
M := TMyThread.Create;
M.WaitFor;
QueryPerformanceCounter(L);
Label1.Caption := IntToStr(L - S);
M.Free;
end;
{ TMyThread }
procedure TMyThread.Execute;
begin
inherited;
end;
end.
It is all about OS time slices. Even if on multi-core/hyper-threaded systems with parallel execution, theoretical near zero thread start time, zero context switching and your thread terminates earlier, you can reach it in next time slice.
Multiple short tasks can be executed in one time slice in a single thread.
Thread pools are useful to get instantly an initialized thread if there are multiple short operations but thread initialization take some time.
Slice time is well balanced in OS between context switching time cost and responsivity. Even if there are ways to decrease it to 1ms - 0.5ns, if hardware architecture permits, a lower slice time is not always better.
Edit: Some technologies, like Intel Hyper-Threading allow execution on multiple threads on the same core in the same time slice, see comments.

Answer 2

Timing short threaded applications can be misleading using Delphi because most people are used to doing such timings in the IDE. If you are running in the IDE, thread startup is quite slow, ~ 20 - 40 ms as described in this post. Possibly this is because when running in the IDE there is text send to the "messages" about threads starting and stopping which may be synchronized with the main IDE thread.
Timing outside the IDE by myself and others above on many computers seems to indicate that on windows thread creation/destruction takes between 0.1 and 0.4 msec depending on the computer. Of course, test on your own target computers to confirm. Just make sure to test outside the IDE.
Threadpools then do play a role in Delphi. One, they can very much speed up timing inside while debugging inside the IDE. Also, depending on the threadpool, I have obtained task startup times of 0.01 msec to start the task. Thus, for short tasks that only take 1-2 msec on their own when threaded, the benefits of a shorter task startup time can be meaningful.
However, for most people, where the threads run longer than a 20 msec or so, using a threadpool probably provides negligible benefit.