tthread | TinyThread fork with lambda , future and continuation | Reactive Programming library

The TTimer is being constructed in the main UI thread, when the TForm streams in its DFM resource. The TTimer's constructor creates an internal HWND for the timer to receive WM_TIMER messages with. That HWND is thus owned by the main UI thread.

TForm.Notify() is setting the timer's Enabled property to true, which will call SetTimer(). Notify() is being called in the context of the worker thread, not the main UI thread. This SHOULD NOT work, as stated in SetTimer()'s documentation. Only the main UI thread should be able to start the timer running, since the main UI thread owns the timer's HWND.

TTimer.UpdateTimer(), which is called internally by the setters of the timer's Enabled, Interval and OnTimer properties, will raise an EOutOfResources exception if SetTimer() fails. So, calling form1.Notify() in TypeThreadTest.Execute() SHOULD NOT work. The only way SetTimer() would not be called in that situation is if either:

• Interval is 0
• Enabled is false
• OnTimer is unassigned

Otherwise, your worker thread SHOULD be crashing.

As you have noted, your worker thread can alternatively use TThread.Synchronize() (or TThread.Queue()), or PostMessage() (or SendMessage()), when it wants to notify the main UI thread to do something. These are viable and preferred solutions. Personally, I would opt for TThread.Queue(), eg:

You can't directly access UI controls from within a worker thread, like you are doing. You MUST synchronize that access to the main UI thread.

Thanks to the comment from @IInspectable, that's the hint i needed.

Solution:
Add CoInitialize before calling GetExtractImageItfPtr and add CoUninitialize after receiving the file preview, but still within the worker thread.
Ensure that CoUninitialize is called even if exceptions occur by using try and finally`.

Working source code for main unit with worker thread:

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.

DirectX uses ActiveX/COM interfaces. As such, your thread's Execute() method needs to initialize the COM library for itself via CoInitialize/Ex() before accessing any COM objects.

But more importantly, you are creating and using the TVideoImage object across thread boundaries. Most COM objects are not designed to be used across thread boundaries, they would have to be marshaled in order to do that. So don't use TVideoImage that way. Create, use, and destroy it all within the same thread (ie, inside your Execute() method).

Try this instead:

The answer is simple: You don't have to do anything special. The ITask interface returned by the TTask.Create call is also "held onto" internally by the InternalExecute method, so the underying TTask object will be destroyed by means of reference counting. If the "Master" thread does not hold on to the ITask interface, the subthread will. Until it has terminated.

So using TTask this way is pretty straightforward.

NOTE: In RS10.4.2 this works, I suspect using captured interface variables may cause a problem in 10.4.1 and earlier due to inline var problems combined with anonymous procs. (Didn't try)

When compiling this code as a program, at runtime it will try to terminate itself when end. is reached, before the worker thread even has a chance to run, which could possibly (and likely) happen after the Application object has been destroyed. You would have to wait for the worker thread to finish its work before letting the program exit, eg:

The documentation is correct. The OnTerminate event handler is always run in the main thread by default. Internally, TThread.DoTerminate() (which is called after the thread's Execute() method exits) uses TThread.Synchronize() to call the handler:

For all labels, for which you want to manipulate the Style property, you need to remove the Style setting from StyledSettings.

(As the color change works, you already removed the FontColor setting from StyledSettings)

Actually, if you set any of these settings at design time, the IDE removes the corresponding StyledSetting. If you don't change any of these settings at design time, you must remove the corresponding StyledSettings before you can change the setting at runtime.