Результат возврата потомка Delphi TThread

В основном результат в конце Execute - это просто целое число, которое должно быть передано в основной поток.

Я читал о ReturnValue, но не знаю, как его использовать.

Использовать свойство ReturnValue очень просто:

type
  TCongruenceSystem = class(TThread)
    ... 
  protected
    procedure Execute; override;
  public
    property ReturnValue; // protected by default
  end;

procedure TCongruenceSystem.Execute;
var
 ...
begin
  // computation
  ReturnValue := ...;
end;

test := TCongruenceSystem.Create(...);
test.OnTerminate := giveMeSolution;
test.Start;

....

procedure TMyForm.giveMeSolution(Sender: TObject);
var
  Result: Integer;
begin
  Result := TCongruenceSystem(Sender).ReturnValue;
  ...
end;

Предположим, поле класса FFoo : integer;;

 procedure TFoo.Foo(var x : integer);
 begin
   FFoo := x;
 end;

Здесь вы присваиваете значение x FFoo. Внутри метода Foo вы можете изменять значение переменной, переданной как x, но integers в противном случае являются типами значений, которые копируются при присваивании. Если вы хотите сохранить ссылку на внешнюю переменную integer, вам нужно будет объявить FFoo (или, в вашем случае, resInner) как PInteger (указатель на целое число). Например (упрощая):

TCongruenceSystem = class(TThread)
  private
    resInner: PInteger;       
  protected
    procedure Execute; override;
  public
    constructor Create(result: PInteger);
end;

куда

constructor TCongruenceSystem.Create(result: PInteger);
begin    
  inherited Create(True);
  FreeOnTerminate := true;      
  resInner := result;    
end;

который вы бы назвали test := TCongruenceSystem.Create(@a); и назначили:

 { ** See the bottom of this answer for why NOT to use }
 {    Queue with FreeOnTerminate = true **             }
 Queue( procedure
    begin
      ShowMessage('r = ' + sysResult.ToString);
      resInner^ := sysResult;
    end );

Причина, по которой он работает с TMemo, заключается в том, что классы являются ссылочными типами - их переменные не содержат значений, а скорее указывают на адрес объекта в памяти. Когда вы копируете переменную класса, вы копируете только ссылку (например, указатель), тогда как для типов значений содержимое переменной копируется при назначении.

С учетом сказанного, ничто не мешает вам сохранить аргумент, набранный как var x : integer, и взять ссылку в свой конструктор:

constructor TCongruenceSystem.Create(var result: Integer);
begin    
  inherited Create(True);
  FreeOnTerminate := true;      
  resInner := @result;   {take the reference here}   
end;

но это создает у вызывающей стороны впечатление, что как только конструктор завершен, вы внесли какие-либо изменения в переменную, которую намереваетесь, и они могут избавиться от целого числа. Явная передача PInteger дает вызывающей стороне подсказку, что ваш объект будет хранить ссылку на целое число, которое они предоставляют, и что необходимо гарантировать, что базовая переменная остается действительной, пока ваш класс жив.

И ... несмотря на все сказанное, мне все еще принципиально не нравится эта идея. Принимая такую ​​ссылку на переменную, вы перекладываете на вызывающего абонента нетипичную проблему управления временем жизни. Указатели передачи лучше всего делать там, где они используются только в точке передачи. Держаться за чужой указатель беспорядочно, и слишком легко сделать ошибку. Гораздо лучшим подходом здесь было бы предоставить событие завершения и прикрепить обработчик к потребителю вашего класса.

Например:

  { define a suitable callback signature }
  TOnCalcComplete = procedure(AResult : integer) of object;

  TCongruenceSystem = class(TThread)
  private
    Fx, Fy : integer;
    FOnCalcComplete : TOnCalcComplete;
  protected
    procedure Execute; override;
  public
    constructor Create(x,y: integer);
    property OnCalcComplete : TOnCalcComplete read FOnCalcComplete write FOnCalcComplete;
  end;

constructor TCongruenceSystem.Create(x: Integer; y: Integer);
begin
  inherited Create(true);
  FreeOnTerminate := true;
  Fx := x;
  Fy := y;
end;

procedure TCongruenceSystem.Execute;
var
  sumOfxy : integer;
begin
  sumOfxy := Fx + Fy;
  sleep(3000);        {take some time...}
  if Assigned(FOnCalcComplete) then
    Synchronize(procedure
                begin
                  FOnCalcComplete(sumOfxy);
                end);
end;

Что бы вы затем назвали:

{ implement an event handler ... }
procedure TForm1.CalcComplete(AResult: Integer);
begin
  ShowMessage(IntToStr(AResult));
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  LCongruenceSystem : TCongruenceSystem;
begin
  LCongruenceSystem := TCongruenceSystem.Create(5, 2);
  LCongruenceSystem.OnCalcComplete := CalcComplete;  { attach the handler }
  LCongruenceSystem.Start;
end;

Вы также заметите, что я использовал здесь Synchronize вместо Queue. По этой теме, пожалуйста, прочтите этот вопрос (я процитирую Реми ...):

Убедитесь, что все методы TThread.Queue завершены, прежде чем поток самоуничтожится

Установка FreeOnTerminate: = True в методе с очередью запрашивает утечку памяти.