Fragen zu Threads

[monty.ms]

Hallo zusammen,

Ich habe zwei Fragen, wie ich folgendes am besten umsetze:

Das erste: Ist das richtig, dass man auch Events mit Sychronize auslösen muss?

Delphi-Quellcode:

procedure TMyThread.Execute();
begin
  Synchronize(MyProcedure);
end;

procedure TMyThread.MyProcedure();
begin
  OnSomething(self);
end;

...

type
  Form1 = class(TForm1)
    procedure OnSomeThing(Sender: TObject);
  private
  public
    MyThread: TMyThread;
  end;

...
MyThread.OnSomething := OnSomething;
...

Und meine zweite Frage wäre: Wie übergebe ich am besten eine StringList an ein Thread?

Delphi-Quellcode:

procedure TForm1.erstelleListe();
var List: TStringList;
begin
  List := TStringList.Create();
  List.add('123');

  MyThread.listeHinzufuegen(List);
end;

Auf die Liste wird nach der Übergabe nicht mehr zugegriffen (außer von MyThread). Ist das sicher? Oder wie lassen sich sonst am besten Objekte übergeben, während der Thread läuft.

Vielen Dank schonmal für jede Hilfe.

monty

[alleinherrscher]

Weiß zwar nicht, obs die idealste Lösung ist: Aber ich synchronisiere meine Events auch immer.

Auch den zweiten Punkt mit der Liste würde ich so machen... aber wie gesagt...bin kein Threadexperte ;-)

[Chris.R]

Hallo,

zu erstens: Richtig, du musst auch Events über Synchronize aufrufen, wenn sie außerhalb des Threads verarbeitet werden,
da ein Event nichts anderes ist, als ein Methodenaufruf.

zu zweitens: Wenn du die StringList erstellst, bevor der Thread startet (also CreateSuspended = true) und der Thread dann die StringList wieder frei gibt,
kein Problem.

Das kannst du dann aber auch so lösen:

Delphi-Quellcode:

TTestThread = class(TThread)
protected

public
  constructor Create; virtual;
  destructor Destroy; override;
  property SL: TStringList read FSL;
end;

constructor TTestThread.Create;
begin
  Inherited Create(true);
  FSL := TStringList.Create;
end;

destructor TTestThread.Destroy;
begin
  FSL.Free;
  Inherited;
end;

// und so die Benutzung
procedure TForm1.erstelleListe();
var pThread: TTestThread;
begin
  pThread := TTestThread.Create;
  pThread.FreeOnTerminate := true;

  pThread.SL.Add('Test');
  pThread.SL.Add('1234');

  pThread.Resume;
end;

Ciao Chris

[monty.ms]

Danke euch beiden zu den schnellen Antworten.

Zu erstens: Ok, dann hab ich da eine weiterführende Frage: Die Events haben ja in der Regel einen oder mehr Parameter. Synchronize kann man hingegen nur Methoden übergeben, die keine Parameter enthalten. D.h. ich müsste die komplette Methode, in der das Event ausgelöst wird, mit Synchronize ausführen. Hat das Nachteile? Bzw. Gibt es eine erweiterte Form von Synchronize?

Zu zweitens: Der Thread wird vorher gestartet. Die Liste enthält mehrere Befehle und wird innerhalb des Threads in ein Objekt umgewandelt, welches späterhin (innerhalb des Threads) abgearbeitet werden soll. Die Liste wird also nur kurz in Anspruch genommen und dann vom Thread wieder freigegeben. Kann ich das dann trotzdem so machen, wie oben geschrieben?


monty

[Chris.R]

Hallo,

wenn du Daten an den Thread übergeben willst, während er läuft, dann musst den Zugriff immer synchronisieren.

Z.B. mit einer CriticalSection

Delphi-Quellcode:

constructor TTestThread.Create;
begin
  Inherited Create(true);
  FCriticalSection := TCriticalSection.Create;
end;

function TTestThread.GetSLItem(AIndex: integer): string;
begin
  FCriticalSection.Enter;
  try
    Result := FSL[AIndex];
  finally
    FCriticalSection.Leave;
  end;
end;

procedure TTestThread.AddSLItem(const s: string);
begin
  FCriticalSection.Enter;
  try
    FSL.Add(s);
  finally
    FCriticalSection.Leave;
  end;
end;

Ist jetzt nicht sonderlich ausgestaltet. Die Methode AddSLItem benutzt du um neue Einträge hinzuzufügen, GetSLItem um einen String aus der Liste abzurufen.

Ciao Chris

[monty.ms]

Hallo,

vielen Dank, ich denke mir leuchtet das mit der CriticalSection ein, nur das Beispiel verwirrt mich jetzt etwas :)

Die CriticalSection bezieht sich ja allein auf TestThread. Der Hauptthread kennt die Section ja nicht. Und die beiden Funktionen können sich ja nicht überschneiden, da sie nicht gleichzeitig innerhalb des Threads ausgeführt werden können.
Ich nehme also mal an, dass erst wenn der TestThread und die Form auf eine Ressource zugreifen (z.B. eine StringList), eine global definierte CS nötig ist, oder?

monty

[Luckie]

@Chris.R: Aber doch nicht für eine Stringlist, die zum Thread gehört. Ist es eine Stringliste, auf die auch andere Threads zugreifen, dann ja.

[himitsu]

Soweit hast du es richtig gesehn, der Hauptthread kennt wirklich nicht diese CriticalSection.
Aber wenn du vom Haupthtread oder einem anderem Thread, auf eine der beiden Funktionen zugreifst, dann wird die Section ja gesperrt und dann kann auch der Thread selber nichts machen.


Es ist hier praktisch (nur) diese Resource über diese Section abgesichert, wenn alles was darauf zugreift über diese Section läuft, egal von wo (welchem Thread) es kommt.

[Sir Rufo]

Zitat:

Zitat von Luckie

@Chris.R: Aber doch nicht für eine Stringlist, die zum Thread gehört. Ist es eine Stringliste, auf die auch andere Threads zugreifen, dann ja.

:wiejetzt:
Aber genau das war doch damit gemeint, dass die Daten von einem anderen Thread übergeben werden. Somit ist die CS hier zurecht angebracht.

Delphi-Quellcode:

// und so die Benutzung 
procedure TForm1.erstelleListe(); 
var pThread: TTestThread; 
begin 
  pThread := TTestThread.Create; 
  pThread.FreeOnTerminate := true; 

  pThread.SL.Add('Test'); 
  pThread.SL.Add('1234'); 

  pThread.Resume; 
end;

In diesem Beispiel ist zwar der Thread bei der Zuweisung noch am Schlafen - es sollte also gutgehen - aber sauberer auf jeden Fall mit einer CS, da die Zuweisung definitiv von aussen erfolgt.

cu

Oliver

[Chris.R]

Hallo,

@monty.ms: Der Hauptthread muss die CS auch nicht kennen, da er einfach über die Methode AddSLItem neue Einträge hinzufügt
und in der Funktion wird ja die CS benutzt. Soweit klar?

Ciao Chris