Eine wichtige Frage habe ich noch bevor es weiter gehen kann.

Zitat:

Und "Uses unit1" hat in der ThreadUnit nichts verloren.

Nun, wie gebe ich die Werte wieder zurück ?
In meinem Fall ist es eine
- Stringlist, die im Thread bearbeitet und zurück gegeben werden soll.
- Ein String, der in eine ListBox einzufügen ist
- Ein Integer der sich immer ändert. Sprich ist starte mehrere Threads (ohne Event) einfach

markieren

Delphi-Quellcode:

  for i := 1 to 1 do
    begin
      Thread[i] := TMyThread.Create(True);
      Thread[i].Liste := Liste;
      Thread[i].FreeOnTerminate := True;
      Thread[i].Resume;
    end;

Nun, wird etwas im Thread gemacht und mein Progressbar muss aktualisiert werden.
Wie gibt man so was zurück ohne
uses Unit1 im Thread ?

Etwa über property , aber in andere Richtung? --> wohl kaum.

FreeOnTerminate und Resume ist keine gute Idee, da der Thread dann evtl. so schnell weg ist, dass es Zugriffsprobleme gibt.
Und einen Thread, der auf FreeOnTerminate gesetzt ist, in einer Liste zu speichern ist ein No-Go, denn du weißt nie, wann du noch darauf zugreifen kannst.

Du musst dich entscheiden:
Möchtest du von außen deine TThread-Objekte in einer Liste haben, dann musst du diese auch von außen am Ende freigeben. Oder du benutzt FreeOnTerminate, überlässt die Threads dann aber auch sich selbst.

Zudem ist es auch viel einfacher, wenn du deine Liste gleich im Konstruktor übergibst. Zur Aktualisierung der Progressbar gibt es mehrere Möglichkeiten, eine ist mit Snychronize zu arbeiten, aber das bremst den Thread aus. Alternativ schick einfach mit PostMessage eine Message an das Hauptfenster, dann macht Windows die Synchronisation für dich.

Zitat:

Zudem ist es auch viel einfacher, wenn du deine Liste gleich im Konstruktor übergibst.

So weit bin ich noch nicht. Wie schon gesagt Step by Step.

Zitat:

Alternativ schick einfach mit PostMessage eine Message an das Hauptfenster, dann macht Windows die Synchronisation für dich.

Damit komme ich ohne Beispiel nicht klar. Wäre aber interessante Sache.

Bis jetzt Alles was ich gelesen habe arbeitete mit Synchronize. Ob es nun etwas langsamer ist , ist für mich nicht wirklich wichtig, ich versuche halt nach und nach die Sache zu verstehen. Allerdings bei Synchronize kann man kaum auf Uses UNIT1 verzichten.
Ganz so einfach ist das doch nicht. Leider. Ich versuche wie gesagt nach und nach etwas mehr zu verstehen.

Zitat von IMPEGA:

Etwa über property , aber in andere Richtung? --> wohl kaum.

Eben, dann bekommst du eine Zirkularität rein, auch wenn der Compiler das unterhalb von implementation akzeptieren würde.

Kleines ThreadBeispiel mit Events:

Danke dir. Das muss ich zuerst durch kauen.
Es bringt mich aber schon weiter.

EDIT:
OK, soweit habe ich es verstanden.
Hier passiert nämlich folgendes, wir starten ein Thread erhalten die Information, tragen die in die memo1 ein.
So lange bis wir es terminieren oder ThreadActivate := false;

Nun, gut und schön, ich möchte aber die Möglichkeit haben die Anzahl der Threads zu bestimmen.
Und zwar so dass zB. Meine Liste 10 Einheiten hat, ich die mit 5 Threads abarbeiten möchte.
In Forum habe ich schon etwas gefunden, Threadpool wäre interessant.
Es ist aber noch etwas zu schwer für mich.


@Bjoerk
Dein Beispiel kann ich sehr gut verstehen, kann man das auch so irgendwie realisieren dass man mehrere Threads startet? Ich meine so dass der nächste Thread immer den Nächsten Job übernimmt und nicht so dass man mehrere Threads parallel startet die das Gleiche tun.
Das was ich hier in Forum gefunden habe übersteigt meine Möglichkeiten.(Leider)
Ich versuche es zwar Alles zu verstehen, ganz so einfach ist es aber nicht.

Bezueglich dieses Themas habe ich noch eine weitere Frage:

Ich habe eine Variable folgenden Typs, die im Hauptprogramm global definiert ist:

type TMyVar = record
a : String;
b : String;
c : Array of Array of integer;
d : Integer;
e : Array[1..6,1..6] of double;
end;

var MyVar : TMyVar;


Weder das Uebergeben des Wertes mittels einer Threadprozedur folgender Form

procedure MyThread.setMyVar(var MV : TMyVar);
begin
FMyVar := MV;
end;

(also via MyThread.setMyVar(MyVar) noch die Uebergabe mittels 'property ...' bewirken, dass Aenderungen die der Thread an dem Record durchfuehrt (d.h., an FMyVar) , nach Beendigung des Threads auch and der Originalvariablen MyVar geschehen sind. Wie kann ich es erreichen dass die vom Thread gemachten Aenderungen am Record auch in MyVar geschehen?

Gruesse

Gutelo

Und wenn Du einen Pointer auf den Record an den Thread übergibst und innerhalb des Threads auf diesen zugreifst?

Ich habe gerade nochmal den Informationsfluss von Mainform zu Thread ueberprueft. Der Inhalt des Records im Mainform kommt definitv im Thread an. Kann es sein dass Uebergaben bei Threads nicht per call-by-reference geschehen? Dann wunder ich mich aber, dass bei uebergebenen VCL Komponenten ein synchronize moeglich ist.

Objekte, also auch VCL-Komponenten, werden immer als Referenz übergeben und in Referenzvariablen gespeichert.
Deine interne Record-Variable ist aber keine Referenz, sondern eine Kopie.

zusammenfalten · markieren

Delphi-Quellcode:

type
  PMyVar = ^TMyVar;

  TMyThread = class(TThread)
  private
    FExtVar: PMyVar;
    FMyVar: TMyVar;
    CopyToExtVar;
    DoOnTerminate; override;
  public
    {darf nur im constructor oder vor dem Resume aus dem Hauptthread aufgerufen werden}
    InitMyVar(var MV: TMyVar);
  end;

procedure TMyThread.InitMyVar(var MV: TMyVar);
begin
  {Verweis auf externe Variable}
  FExtVar := @MV;
  {Kopie der externen Variable}
  FMyVar := MV;
end;

procedure TMyThread.DoOnTerminate;
begin
  {wird beim Beenden im Thread aufgerufen}
  if Assigned(FExtVar) then
    Synchronize(CopyToExtVar);
  inherited;
end;

procedure TMyThread.CopyToExtVar;
begin
  {interne Variable in die externe Variable kopieren}
  if Assigned(FExtVar) then
    FExtVar^ := FMyVar;
end;

IIRC wird durch die Zuweisung des Parameters an das private Feld eine Kopie des Records erzeugt, da nützt auch die "var"-Angabe nichts. Übergibt man hingegen den Pointer, arbeitet man tatsächlich mit dem Original. Objektinstanzen sind übrigens intern auch Pointer, daher funktioniert das damit.