Hi Leute.
Ich habe mich ein wenig in Threading eingearbeitet, nun habe ich eine Technische Frage.
Wie macht man es richtig mit den Parametern.
Hier zwei Beispiele, beide funktionieren, meine Frage dazu, was davon ist richtig, bzw. besser.
Ich poste nur das relevante.

Erster Beispiel. Die Variable wird als Public deklariert und in Unit1 einfach gesetzt.

zusammenfalten · markieren

Delphi-Quellcode:

//Unit Thread

type
  TMyThread = class(TThread)
  private
    Wert : String; // Werte der nur im Thread benutzt wird
    Bezeichnung : String; // Werte der nur im Thread benutzt wird
    procedure UpdateStaus;
    procedure Finished;
    procedure Abort;
  public
    SSL : Boolean; // Werte der von der UNIT1 übernommen wird
  protected
    procedure Execute; override;
  end;

implementation
...
...

//in der UNIT1
...
...
  Thread := TImageShackThread.Create(True);
  Thread.SSL := False;
  Thread.FreeOnTerminate := True;
  Thread.Resume;
...

Oder eine zweite Methode

zusammenfalten · markieren

Delphi-Quellcode:

//Und UNIT Thread
type
  TMyThread = class(TThread)
  private
    Wert : String; // Werte der nur im Thread benutzt wird
    Bezeichnung : String; // Werte der nur im Thread benutzt wird
    SSL : Boolean;// Werte der nur im Thread benutzt wird
    procedure UpdateStaus;
    procedure Finished;
    procedure Abort;
  public
    procedure SetSSL(ThreadSSL : Boolean); // Procedure die den Wert übernimmt
  protected
    procedure Execute; override;
  end;

implementation
...
...
procedure TMyThread.SetSSL(ThreadSSL : Boolean); // Damit hab ich mein Wert im Thread zur Verfügung
begin
  SSL := ThreadSSL;
end;
...
...
...

//und in der UNIT1
...
...
  Thread := TMyThread.Create(True);
  Thread.SetSSL(False);
  Thread.FreeOnTerminate := True;
  Thread.Resume;
...

Dafür gibt's properties.

markieren

Delphi-Quellcode:

  private
    FSSL: boolean;
  public
    property SSL: boolean read FSSL write FSSL;

Innerhalb von TMyThread dann mit FSSL arbeiten.

// Edit: wenn man das write weglässt ist die Variable ReadOnly,
wenn man read weglässt WriteOnly.

Kannst mir noch bitte sagen wie ich es dann von der Unit1 übergeben kann?
Ich lerne es erst.

Mir ist noch eine Frage eingefallen.
Irgendwo habe ich den Satz gelesen "alle Zugriffe auf nicht threadsichere VCL-Dinge über Synchronize erledigen"
Wie weit ist es wichtig?
Ist es so schlecht vom Thread aus auf zB. Tform1.Laqbel1 zu zugreifen?

Das Ding mit den Properties hast du noch nicht ganz verstanden

markieren

Delphi-Quellcode:

TMyThread = class(TThread);
private
    FSSL: boolean;
public
    property SSL: boolean read FSSL write FSSL;
end;

SSL kann nun wie eine public-Variable angesprochen werden:

markieren

Delphi-Quellcode:

...
Thread := TMyThread.Create(True);
Thread.SSL := False;
...

Zitat:

Ist es so schlecht vom Thread aus auf zB. Tform1.Laqbel1 zu zugreifen?

Ja. Ist es. Glaub es uns, wir leben damit schon über eine Dekade lang.

Zitat von IMPEGA:

Kannst mir noch bitte sagen wie ich es dann von der Unit1 übergeben kann? Ich lerne es erst.

markieren

Delphi-Quellcode:

  MyThread := TMyThread.Create(True);
  MyThread.SSL := False;

Zitat von IMPEGA:

Mir ist noch eine Frage eingefallen. Irgendwo habe ich den Satz gelesen "alle Zugriffe auf nicht threadsichere VCL-Dinge über Synchronize erledigen"
Wie weit ist es wichtig? Ist es so schlecht vom Thread aus auf zB. Tform1.Laqbel1 zu zugreifen?

Ja. Und das am besten mit Events. Wird aber etwas kompliziert, wenn du nicht weißt, was ein Event ist? Und "Uses unit1" hat in der ThreadUnit nichts verloren.

Danke Euch Jungs. Damit habt Ihr mir gut geholfen.
Das mit Propertys habe ich doch verstanden, sogar darüber gelesen, mir kam es aber so vor als ob es nicht wichtig wäre.
Propertys muss ich mir noch genaue durchlesen. Gar keine Frage.
Das man die so ansprechen kann, habe ich eigentlich gewusst, wollte aber nicht wie ein Trottel da stehen wenn es nicht so wäre, also lieber nachfragen.

Eine Frage hätte ich aber noch.
Wo ist eigentlich der Unterschied zwischen der Methode mit procedure und der Methode mit property.
Es wird doch genauso angewandt.
Sorry für die Neugier, mir geht es mehr darum es zu verstehen wieso und warum. Hinkriegen kann ich es schon, darum geht es aber nicht alleine.
Klar ist der Code kleiner, es muss aber noch mehr sein als nur das.


TMyThread = class(TThread);
private
FSSL: boolean;
public
property SSL: boolean read FSSL write FSSL;
end;




TMyThread = class(TThread);
private
FSSL: boolean;
public
procedure SetSSL(ThreadSSL : Boolean);
end;
implementation
...
...
procedure TMyThread.SetSSL(ThreadSSL : Boolean);
begin
SSL := ThreadSSL;
end;

Zitat:

Ja. Und das am besten mit Events. Wird aber etwas kompliziert, wenn du nicht weißt, was ein Event ist? Und "Uses unit1" hat in der ThreadUnit nichts verloren.

Dazu habe ich ein Beispiel. Kriege es zwar nachgebaut. Eigentlich wenn ich lange genug mir den Code anschaue, verstehe ich es auch, aus dem Kopf würde ich es aber nie im Leben coden können. Egal, ich mache ganz langsam. Step by step.

Parameter werden in der Regel nur einmalig beim Start an den Thread übergeben. Daher ist oft der Konstruktor die einfachste Stelle, alle notwendigen Daten / Parameter in interne (private) Properties des Threads zu übergeben.

Alles was während der Ausführungszeit des Threads (während der Laufzeit der Execute Methode) übergeben oder ausgelesen wird, wie zum Beispiel über Properties, ist erst mal nicht thread safe - man muss diese dann entsprechend absichern, zum Beispiel über Critical Sections.

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.