Question

状况即可。我创建了一个单元，其中包含一些类来解决代数问题（同余和系统），我向您展示代码：

type
 TCongrError = class(Exception)
 end;

type
 TCongruence = class(TComponent)
  //code stuff
  constructor Create(a, b, n: integer); virtual;
 end;

type
 TCongrSystem = array of TCongruence;

type
 TCongruenceSystem = class(TThread)
  private
   resInner: integer;
   FData: TCongrSystem;
   function modinv(u, v: integer): integer; //not relevant
  protected
   procedure Execute; override;
  public
   constructor Create(data: TCongrSystem; var result: integer; hasClass: boolean);
 end;

我决定使用TThread，因为这个类有一个Execute方法，由于传递给构造函数的参数长度，可能需要一些时间才能完成。这是实施：

constructor TCongruenceSystem.Create(data: TCongrSystem; var result: integer; hasClass: boolean);
begin

 inherited Create(True);
 FreeOnTerminate := true;

 FData := data;
 setClass := hasClass;
 resInner := result;

end;

procedure TCongruenceSystem.Execute;
var sysResult, i, n, t: integer;
begin

 sysResult := 0;
 n := 1;

 //computation

 Queue( procedure
        begin
         ShowMessage('r = ' + sysResult.ToString);
         resInner := sysResult;
        end );

end;

问题

如果您查看Queue，您会看到我正在使用（就像测试一样）ShowMessage，它显示sysResult的正确值。顺便说一句，第二行存在一些我无法理解的问题。

构造函数有var result: integer所以我可以从传递的变量中产生副作用然后我可以分配resInner := result;。最后（在队列中）我给了resInner sysResult的值，由于result的副作用，我希望var也被更新。为什么不这样呢？

我做了另一个测试，改变了这样的构造函数：

constructor TCongruenceSystem.Create(data: TCongrSystem; result: TMemo; hasClass: boolean);
//now of course I have resInner: TMemo

将队列更改为：

Queue( procedure
        begin
         ShowMessage('r = ' + sysResult.ToString);
         resInner.Lines.Add(sysResult.ToString);
        end ); //this code now works properly in both cases! (showmessage and memo)

在构造函数中，我传递的是TMemo，这是一个引用并且没问题，但是不是作为参考传递的原始var result: integer吗？那么为什么它不起作用？

我想这样做，因为我想做这样的事情：

 //I put var a: integer; inside the public part of the TForm
 test := TCongruenceSystem.Create(..., a, true);
 test.OnTerminate := giveMeSolution;
 test.Start;
 test := nil;

其中giveMeSolution只是一个使用包含系统结果的变量a的简单过程。如果这不可能，我该怎么办？基本上，Execute结尾的结果只是一个必须传递给主线程的整数。

我已阅读ReturnValue，但我不确定如何使用它。

Answer 1

我们假设一个类字段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。关于这个话题，请读一下这个问题（我引用雷米......）：

Ensure all TThread.Queue methods complete before thread self-destructs

在排队方法中设置FreeOnTerminate：= True会要求内存泄漏。

Answer 2

基本上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;

Delphi TThread后代返回结果

2 个答案: