How the messages are serialized between multiple WndProcs? - multithreading

Question

I created two WndProcs in the main thread and then I post a messages from other threads to each of them, almost at the same time, but starting with WndProc1. This WndProc1 has a job to do which lasts for some time... It sigals when it begins and when it ends. WndProc2 also signal when is accessed. Now, when I press the button to start this test, I get: "P1-Enter ... [delay] ... P1-Leave WndProc2". As you can see, the second message waits for WndProc1 to finish, although he was sent to to WndProc2 ! What I want to know is how this serialization works if those two WndProcs have nothing in common ? I think that even happens if I have two different components, each with his own WndProc (but I didn't check).
unit Unit1;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, SyncObjs;
type
TMyThread = class(TThread)
private
FHnd: HWND;
FTime: Integer;
protected
procedure Execute; override;
public
constructor Create(AHnd: HWND; ATime: Integer);
end;
TForm1 = class(TForm)
Button1: TButton;
procedure FormCreate(Sender: TObject);
procedure Button1Click(Sender: TObject);
private
TestHand1, TestHand2: HWND;
MyT1, MyT2: TMyThread;
protected
procedure TestWndProc1(var Msg: TMessage);
procedure TestWndProc2(var Msg: TMessage);
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
constructor TMyThread.Create(AHnd: HWND; ATime: Integer);
begin
inherited Create;
FHnd:= AHnd;
FTime:= ATime;
end;
procedure TMyThread.Execute;
begin
Sleep(FTime);
PostMessage(FHnd, WM_USER, 0, 0);
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
TestHand1:= AllocateHWnd(TestWndProc1);
TestHand2:= AllocateHWnd(TestWndProc2);
end;
procedure TForm1.TestWndProc1(var Msg: TMessage);
var I: Integer;
A, B, C: Cardinal;
begin
if Msg.Msg = WM_USER then begin
Caption:= Caption + ' P1-Enter';
A:= $12345678; B:= $98765432;
for I:= 1 to 180000000 do begin
C:= A * B; B:= C * A; A:= B * C;
end;
Caption:= Caption + ' P1-Leave';
end;
end;
procedure TForm1.TestWndProc2(var Msg: TMessage);
begin
if Msg.Msg = WM_USER then
Caption:= Caption + ' WndProc2';
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
Caption:= '';
MyT1:= TMyThread.Create(TestHand1, 300);
MyT2:= TMyThread.Create(TestHand2, 350);
end;
end.

Answer 1

What you see is perfectly expected. Each thread has one and only one message queue and may have zero to many window handles. Window handles usually correspond to visual components but not necessarily as in your example.
Somewhere in the code (for a GUI in Delphi, this is in the Forms unit), there is a so called "message loop" which retrieves messages from the queue and dispatches them to the corresponding WndProc. The dispatch mechanism is like a simple function call: it is blocking while a message is being processed, unless the message handler calls the message pump again (where reentrancy problems start, if not handled correctly). Look at the documentation and look in the Forms unit for TApplication.ProcessMessages and in the Classes unit for AllocateHWnd/DeallocateHWnd.
If you want to execute code in parallel you must create separate threads; each one will execute in parallel as long as there are fewer threads than CPU cores and threads are not blocked by I/O or mutexes, semaphores and critical sections. If too many threads are ready to execute they are scheduled using preemptive multitasking.
You can communicate between threads using messages. For that, a thread must create a window handle and have a message pump.
In Delphi, the GUI can only be accessed from the main thread. If a secondary thread has something to display then it must let the display code execute by the main thread, most likely again through a message between the secondary/worker thread and main thread, or use the Synchronize method, or use other communication mechanisms such as pipes, sockets, file I/O, shared memory. Alone or in combination.