Hallo *.*,

um die Reaktionsfähigkeit eines meiner Programme zu verbessern, denke ich gerade darüber nach, Threads zu verwenden, um bestimmte Funktionen von diesem ausführen zu lassen. Die Situation stellt sich folgendermaßen dar:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TfmMain = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    FObject : TComplexClass;
  end;

implementation

procedure TfmMain.FormCreate(Sender: TObject);
begin
    FObject:= TComplexClass.Create(ip);
    if FObject.Ping then begin
    [...]
    end;
end;

Die Ausführung von FObject.Ping kann aufgrund von mir nicht beeinflussbaren Faktoren sehr lange dauern (bei Nichterreichbarkeit der IP durchaus 20 Sekunden). Daher kam mir die Idee, diese Methode in einem Thread auszuführen. Da ich bisher noch nie mit Threads zu tun hatte, habe ich mich natürlich etwas angelesen, neben der Delphi-Hilfe unter anderem das Threads-Tut im Delphi-Treff und auch bei Wikibooks. Einige meiner Fragen wurden durch die Lektüre durchaus beantwortet. Meine Idee ist nun, eine Klasse TPingThread von TThread abzuleiten, und in dessen Execute-Methode irgendwie den Ping auszuführen und dessen Rückgabewert zu speichern. Wenn der Thread fertig ist, will ich im OnTerminate darauf reagieren, je nach Rückgabewert von Ping.

Aber ein paar wichtige Sachen sind mir noch unklar:

• Wie übergebe ich an TPingThread.Create/Execute die Methode Ping? Ich würde ungern das komplette Objekt FObject übergeben. Oder wäre das der richtige Weg?
• Wer setzt ReturnValue? Passiert das bereits in TThread oder müsste ich das in meiner Ableitung TPingThread tun?
• Spricht etwas dagegen, in der Ereignisbehandlung OnTerminate direkt ReturnValue auszuwerten? Ich sehe keinen Sinn darin, WaitFor zu benutzen, denn zu diesem Zeitpunkt hat der Thread ja seine Arbeit bereits erledigt.

Auch diesmal hoffe auf Aufklärung mittels der hier vertretenen Expertise .

Grüße
Dalai

Verstehe die Frage 1 nicht. Du schreibst doch Execute selber. Execute macht an sich überhaupt nichts.

markieren

Delphi-Quellcode:

procedure TMyThread.Execute;
var
  Dings: TDings;
begin
  Dings := TDings.Create();
  Dings.Bums();
end;

Zitat von Redeemer:

Verstehe die Frage 1 nicht.

Dann versuche ich mal, daran etwas zu ändern.

Zitat:

Du schreibst doch Execute selber. Execute macht an sich überhaupt nichts.

Das ist mir schon klar. Aber sowas wie das

Zitat:

markieren

Delphi-Quellcode:

procedure TMyThread.Execute;
var
  Dings: TDings;
begin
  Dings := TDings.Create();
  Dings.Bums();
end;

- also eine Erzeugung von TComplexClass innerhalb des Threads - will ich vermeiden, weil das einen kompletten Umbau bedeuten würde. FObject ist mit Absicht ein Attribut von TfmMain, weil in einigen von dessen Methoden noch eine ganze Reihe anderer Operationen ausgeführt werden, Eigenschaften abgefragt etc - und zwar regelmäßig in Intervallen. FObject nur im Thread zu haben - da weiß ich als Anfänger gar nicht, wo ich anfangen soll, darüber nachzudenken, wie das funktionieren würde. Schließlich ist ein Thread beendet, sobald Execute abgeschlossen ist. Das Objekt muss aber so lange existieren, wie das Programm läuft.

Grüße
Dalai

Dann übergib an den Thread doch einfach nur per Property oder im Constructor die IP-Adresse des Ziel-Rechners. Und dann führst du im Thread den Ping aus und gibst das Ergebnis bspw. per Event zurück. Dann musst du auch beim Auslösen des OnTerminate Events des Threads nicht die Daten selber abholen sondern bekommst sie als Parameter vom eigenen Event geliefert.

Dein Hinweis war möglicherweise der Schubs in die richtige Richtung. Du meinst also etwa in der Art:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TPingThread = class(TThread)
  private
    { Private-Deklarationen }
    FFB: TComplexClass;
  protected
    procedure Execute; override;
  public
    constructor Create(const AHost: string);
    destructor Destroy; override;
    property ReturnValue;
  end;

constructor TPingThread.Create(const AHost: string);
begin
  FreeOnTerminate:= True;
  FFB:= TComplexClass.Create(AHost);
  inherited Create(False);
end;

destructor TPingThread.Destroy;
begin
  FFB.Free;
  inherited;
end;

procedure TPingThread.Execute;
begin
  // Sleep nur zu Zwecken des Debugging
  Sleep(100);
  if Assigned(FFB) then
      ReturnValue:= Integer(FFB.Ping);
end;

Und dann in TfmMain

zusammenfalten · markieren

Delphi-Quellcode:

procedure TfmMain.FormCreate(Sender: TObject);
begin
    // Die Zuweisung von FHostName lasse ich mal mangels Relevanz weg; ist ein privates Attribut der Klasse
    FObject:= TComplexClass.Create(FHostName);
    PingThreadStart;
end;

procedure TfmMain.PingThreadStart;
begin
    FPingThread:= TPingThread.Create(FHostName);
    FPingThread.OnTerminate:= PingThreadDone;
end;

procedure TfmMain.PingThreadDone(Sender: TObject);
var
  Lsucc: Boolean;
begin
    Lsucc:= Boolean(FPingThread.ReturnValue);
    if Lsucc then
        Self.Caption:= 'Connected to ' + FObject.HostName
    else
        MessageBox(Self.Handle, PChar(FObject.HostName + ' not available'), '', MB_OK or MB_ICONINFORMATION);
end;

Das funktioniert. Zwei Sachen stören mich:

• Redundanz durch die Erzeugung der zweiten Instanz von TComplexClass in TPingThread und ggf. Zuweisung der nötigen Eigenschaften, auch wenn letzteres derzeit zum Glück nicht nötig ist.
• Es gibt Speicherlecks, wenn der Thread vorzeitig terminiert (während TPingThread.Execute noch läuft):
  markieren

  Code:

  ---------------------------
  Unexpected Memory Leak
  ---------------------------
  An unexpected memory leak has occurred. The unexpected small block leaks are:
  
  1 - 12 bytes: TObject x 1
  21 - 28 bytes: AnsiString x 1
  61 - 68 bytes: Unknown x 1
  69 - 76 bytes: TPingThread x 1
  269 - 284 bytes: TComplexClass x 1
  
  ---------------------------
  OK  
  ---------------------------
  Sind diese Lecks von Bedeutung?

Grüße
Dalai

In der Art..
Warum muß die eierlegende Wollmilchsauklasse dem Thread bekannt sein? Der Thread hat eine (kleine) Aufgabe zu erledigen, und dabei sollte er sich auf seinen Hinterhof beschränken, auf dem sich aber auch niemand anders herum treiben sollte. Und wenn er fertig ist, dies dem Mainthread mit einem Postmessage bekannt geben.

Gruß
K-H