Synchronize mit Argumenten

[Sir Rufo]

Verflixte Technik ... geht doch nicht, da "Symbol SyncError kann nicht erfasst werden"

Na dann am besten auf XE umsteigen

Zitat von Sir Rufo:

Tja, das ist mit der Delphi-Version blöde ... bei den neueren Versionen macht man das ganz charmant über Anonyme Methoden.

Aber so sollte es auch charmant gehen:

Delphi-Quellcode:

type
  TInstError = procedure(const Content: String) of object;
 
  TMyOwnThread = class(TThread)
  private
    FInstError: TInstError;
    // procedure SyncError; @DeddyH: logisch muss die hier raus :o)
    CallError( const Content : string );
  public
    property InstError: TInstError read FInstError write FInstError;
  end;
 
implementation

procedure TMyOwnThread.CallError( const Content : string );
procedure SyncError;
begin
  if Assigned( FInstError )
    then FInstError( Content );
end;
begin
  Synchronize( SyncError );
end;
 
procedure TMyOwnThread.Execute;
begin
  ...
  // Error 1
  CallError( 'Fehler 1' );
  ...
  // Error 2
  CallError( 'Fehler 2' );
  ...
  // Error 3
  CallError( 'Fehler 3' );
  
  usw.
end;


procedure Form1.InstError(const Content: String);
begin
  RichEditError.Lines.Add(Content);
end;

[Viktorii]

Erstmal vielen Dank an alle für die Antworten.

Ich habe den Unterschied zwischen Syncronize und Queue nicht so wirklich verstanden. Und die Hilfe hilft mir beim Verständnis auch nicht wirklich weiter.

Kann mir das jemand mal erläutern wann ich Queue verwenden kann und wann ich es nicht darf?

[DeddyH]

Soweit ich es selbst verstanden habe, verhält es sich ähnlich wie bei SendMessage(Synchronize) und PostMessage(Queue): bei Synchronize wartet der Thread, bis der HauptThread die angegebene Methode abgearbeitet hat, bei Queue wird dem HauptThread einfach die Methode "aufs Auge gedrückt", und der Thread läuft weiter. Somit kann bei Verwendung von Queue die Gefahr bestehen, dass der HauptThread nur noch damit beschäftigt ist, die aufgelaufenen Methodenaufrufe abzuarbeiten, nämlich wenn er länger für die Abarbeitung braucht als der Thread. Aber das sind jetzt keine gesicherten Angaben, sondern nur meine Interpretation. Sollte ich mich irren, bitte ich einen Wissenden um Korrektur.

[Sir Rufo]

@DeddyH: genau so ist es und genau so steht es in der Hilfe

Zitat von Queue:

Führt einen Methodenaufruf im Haupt-Thread asynchron aus.

Zitat von Synchronize:

Führt einen Methodenaufruf im Haupt-Thread aus.

[Viktorii]

Hmm... Okay. Wenn das denn nun wirklich so ist Wie ist dass dann bei dem Lösungsansatz von DeddyH und Bummi:

Delphi-Quellcode:

procedure TMyOwnThread.SyncError;
begin
  if Assigned(FInstError)
    then FInstError(FError);
end;
 
procedure TMyOwnThread.Execute;
begin
  ...
  // Error 1
  FError := 'Error 1' ;
  Queue(SyncError);
  ...
  // Error 2
  FError := 'Error 2' ;
  Queue(SyncError);
  
  usw.
end;

Wenn Error 1 und Error 2 schnell hintereinander ausgeführt werden und der Hauptthread langsam ist, dann würde FError ja evtl. schon verändert worden sein bevor der Hauptthread FError unter Error 1 ausgelesen hat!?!

Also das typische Problem bei zwei Threads und einer Resource. Also könnte man Critical Sections verwenden. Aber dann wäre man wieder blockieren

Da beißt sich die Schlange wieder selbst in den Schwanz

[DeddyH]

Ob FError in der Zwischenzeit den Wert geändert hat, dürfte keine Rolle spielen, da die Methode ja bereits mit dem entsprechenden Parameter in die Abarbeitungsschleife des MainThreads gestellt wurde.

[Viktorii]

Leider funktioniert es nicht.

Habe mal folgenden Versuch gemacht:

Delphi-Quellcode:

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    FMyThread: TMyThread;
    procedure progress(value: Integer);
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  Memo1.Clear;
  FMyThread := TMyThread.Create(true);
  FMyThread.Progress := progress;
  FMyThread.Resume;
end;

procedure TForm1.progress(value: Integer);
begin
  Memo1.Lines.Add('Value: ' + IntToStr(value));
  sleep(500);
end;

Delphi-Quellcode:

type
  TProgress = procedure(Value: integer) of object;

type
  TMyThread = class(TThread)
  private
    FValue: Integer;
    FProgress: TProgress;
    procedure SyncProgress;
  protected
    procedure Execute; override;
  public
    property Progress: TProgress write FProgress;

  end;

implementation

uses
  Windows, SysUtils;
{ TMyThread }

procedure TMyThread.Execute;
var
  i: Integer;
begin
  for i := 1 to 10 do
  begin
    FValue := i;
    Queue(SyncProgress);
    sleep(200);
    OutputDebugString(PWideChar('FValue: ' + IntToStr(FValue)));
  end;
end;

procedure TMyThread.SyncProgress;
begin
  FProgress(FValue);
end;

Die Ausgabe sieht so aus:

Zitat:

Value: 1
Value: 3
Value: 5
Value: 8
Value: 10
Value: 10
Value: 10
Value: 10
Value: 10
Value: 10

[DeddyH]

Und bei Synchronize stimmt das Ergebnis?

[himitsu]

Nur um es mal erwähnt zu haben:

Delphi-Quellcode:

var S: String;

begin
  ...
  S := 'Hallo';
  TThread.Synchronize(nil, 
    procedure 
    begin
      Memo1.Lines.Add(S);
    end);
  ...
end;

PS: Ein Delphi/RAD 2009/2010/XE ist dafür schon nötig.

[Rob09]

Sir Rufo hat folgendes vorgeschlagen (Beitrag #4):

Zitat:

Delphi-Quellcode:

procedure TMyOwnThread.CallError( const Content : string );
procedure SyncError;
begin
  if Assigned( FInstError )
    then FInstError( Content );
end;
begin
  Synchronize( SyncError );
end;

Bei mir meckert der Compiler da aber in der Synchronize(...)-Zeile: "Incompatible types: 'method pointer and regular procedure'". Jemand ne Ahnung, woran das liegen könnte? Delphi 6?

Gruß!
Robert