multithreading in another unit in Delphi - multithreading

Question

I have a number crunching application in a unit called Execution that is called from the main form. Vey often the code in Execution.pas needs to run 10-15 times in a row and I am looking an efficient way to apply multi-threading, so that the calculations on the Execution unit run in parallel. A simplified version of the code is as follows:
Main Form with one Button1 in it:
unit MainForm;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Execution;
type
TMainForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
end;
var
MainForm1: TMainForm1;
implementation
{$R *.dfm}
procedure TMainForm1.Button1Click(Sender: TObject);
var
ExecutionThread: TThread;
run_ID: integer;
begin
for run_ID := 0 to 2 do
begin
ExecutionThread := TThread.CreateAnonymousThread(
procedure
begin
Execution.CalculateSum;
end);
ExecutionThread.FreeOnTerminate := true;
ExecutionThread.Start;
end;
end;
end.
Execution.pas unit:
unit Execution;
interface
uses System.SysUtils, Vcl.Dialogs;
procedure CalculateSum;
procedure IncrementSum(var Sum: integer);
implementation
const
NoOfTimes = 100;
var
Sum: integer;
procedure CalculateSum;
var
i: integer;
begin
Sum := 0;
for i := 0 to Pred(NoofTimes) do
begin
IncrementSum(Sum);
end;
ShowMessage('Sum = ' + IntToStr(Sum));
end;
procedure IncrementSum(var Sum: integer);
begin
Inc(Sum);
Sleep(10);
end;
end.
If I execute the simplified code, I get three messages with sums close to 300, but not 300 (285, 287, 289), which is expected, since all the threads change the same global variable Sum at the same time and sometimes the incrementations overlap.
Is there an easy way to allocate different memory to each thread, so that I get three messages with sums 100? Or do I have to hard code it myself, allocating different Execution variables in each thread?
Note that the original application that I have contains some thousands variables and records, hence I am looking for a fast way to do this without changing significantly the code (if there is any, of course).
Thank you in advance.

Answer 1

Don't write to the same variable from multiple threads without synchronization or you risk corrupting the data of that variable.
So instead of calling IncrementSum(Sum) in your thread call Synchronize(IncrementSum(Sum)).
This forces procedure IncrementSum to be executed within the scope of the main thread and thus prevents multiple of your worker threads to be modifying that variable at the same time and thus causing potential data damage.
Also you may want to avoid updating this global variable from each loop cycle of every of your worker threads. If you have 10 of your worker threads all waiting for global thread to update this global variable they might end up spending most of their time waiting for main thread to proces their Synchronize calls.
Se perhaps you should consider updating this global variable ever 10 or so cycles for instance. The number of cycles between you go and updating the global variable would depend on how fast each cycle is finished. faster the cycles are done more cycles it is work to wait before updating the global variable and thus reducing the number of Synchronize calls and thus putting less load on the main thread.

Answer 2

Is there an easy way to allocate different memory to each thread, so
that I get three messages with sums 100?
There is a really easy way to allocate different memory to each thread and yet use the same declaration: Use the threadvar keyword.
Here is the code changed:
unit Execution;
interface
uses
System.SysUtils, Vcl.Dialogs;
procedure CalculateSum;
procedure IncrementSum(var Sum: integer);
implementation
const
NoOfTimes = 100;
threadvar // <==== ONLY CHANGE IS HERE
Sum: integer;
procedure CalculateSum;
var
i: integer;
begin
Sum := 0;
for i := 0 to Pred(NoofTimes) do
begin
IncrementSum(Sum);
end;
ShowMessage('Sum = ' + IntToStr(Sum));
end;
procedure IncrementSum(var Sum: integer);
begin
Inc(Sum);
Sleep(10);
end;
end.

Answer 3

Have you thought about using TCriticalSection in System.SyncObjs ?
Only one thread can enter the TCriticalSection at a time, so if a thread enters, modifies shared variables, and leaves, then each thread will wait for the others.
If you are spending most of the time in the TCriticalSection this won't help you scale, because your threads will be mostly waiting for the object, but it does ensure that only one thread is modifying the data protected with the TCriticalSection at a time.
So if your code is continually updating shared variables this will stop them clashing but not really provide the benefit of separate threads. If, however, the threads are doing significant calculation without modifying variables then this allows that code to execute in parallel.