Delphi einfaches Multithread Beispiel.

[Gausi]

Gut, dann lag ich ja richtig.

@Redeemer: danke für den Link. Schau ich mir bei Gelegenheit mal genauer an!

[gemy]

habe mir nun https://www.youtube.com/watch?v=WOc89TF8l-8 angesehen.

Wie kann ich den thread löschen ?

[Redeemer]

Zitat von gemy:

habe mir nun https://www.youtube.com/watch?v=WOc89TF8l-8 angesehen.

Wie kann ich den thread löschen ?

Thread löschen ist immer blöd, so können andere den hier gegangenen Gedankengang nicht nachvollziehen. Verschieben wäre besser.

[Sherlock]

Den Thread würde ich nicht löschen wollen. Ich empfinde ihn als gutes Tutorial, wie man hier gemeinsam zu der Lösung eines Problems kommen könnte, nebst sinnvoller Nebenschauplätze.

Sherlock

[Luckie]

Ich meine, ich habe in meinem Threadtutorial zwei einfache Beispiele. Eins für die WinAPI und eins für die VCL. Nebenbei kann man damit auch etwas tiefer in die Materie einsteigen.

[p80286]

Delphi-Quellcode:

procedure TmyThread.Syni;
begin
form1.Caption:= inttostr(i);
end;

procedure TmyThread.Synthreads;
var line: integer;
begin
form1.memo1.clear;
for line := Low(threads) to High(threads) do
form1.Memo1.Lines.Add(inttostr(threads[line]));
end;

Du setzt zwingend vorraus, das es ein Form1 gibt. Das ist mindestens leichtsinnig. Falls Du auf eine variable ausserhalb Deines Objektes zugreifen willst solltest Du diese auch offensichtlich übergeben.


if ((meinThread[i] <> nil ) and (meinThread[i].Terminated = false)) then meinThread[i].Terminate; Du bist schon weiter oben darauf hingewiesen worden, daß dies eher suboptimal ist.

Gruß
K-H

[Luckie]

Link vergessen: http://michael-puff.de/Programmierung/Delphi/Tutorials/

[himitsu]

Jo, auch für die Wiederverwendbarkeit vorn Code ist es ungut hier "global" auf Form1 zuzugreifen,
sondern man könnte hier ein TMemo (Memo1) oder besser noch TStrings (Memo1.Lines) reingeben, denn dem kann man auch antere StringListen als Log reingeben.
Aber am Besten ist hier ein CallBack zuräck in die Form, wo die Form oder sonstwer dann mit dem LogText machen kann, was er will, ohne dass man an ein TMemo auf einer Form1 gebunden ist.

Zitat von p80286:

if ((meinThread[i] <> nil ) and (meinThread[i].Terminated = false)) then meinThread[i].Terminate;

if ... = False then
Wer möchte dafür mit einem rosa Wattebausch gesteinigt werden?

Und ratet mal was Terminate macht?
Genau, es setzt nur Terminated auf True, also unnötig das nochmal zu prüfen, denn TRUEr als TRUE kann es nicht werden.

Delphi-Quellcode:

if Assigned(meinThread[i]) then 
  meinThread[i].Terminate;

Und schon ist die Zeile extrem übersichtlich.

[himitsu]

@p80286

Ja, es ist schon recht schwer zwei Threads fast zur selben Zeit auf die selbe Speicheradresse zugreifen zu lassen, womit es auch schonmal jahrelang gut gehn "kann",
vor allem da in Delphi standardmäßig alle Variablen absichtlich gut ausgerichtet sind.

OK, im Prnzip hat der RAM "grundsätzlich" nur Adressleitung, womit es unmöglich wäre genau gleichtzeitig zuzugreifen,
aber fangen DualChanel an (zwei Adressleitungen) oder DoubleDataRate (DDR) wo zwei Zugriffe auf einer Leidung liegen (einer bei steigender Flanke und der andere bei Fallender) ..........

Und wenn wir es uns jetzt noch einfach machen und annehmen, dass Speicherzugriffe immer genau auf 4 Byte ausgerichtet sind
und du einen Integer zwischen zwei Zugriffspunkten positionierst, dann sind es zwei einzelne Zugriffe, die dann noch entsprechen maskiert, verschoben und kombiniert werden.

Zitat:

#### #### #### #### #### RAM
x xxx unser Integer

Hier wird dann der erste Integer gelesen aus dem RAM gelesen, das letzte Byte genommen und nach links verschoben, danach dann noch er zweite Integer um ein Byte nach rechts und alles ORen.

Hier ist die Chance gleich ein Vielfaches höher, das Threads sich dabei überschbeiden.

> Wert aus RAM in Register kopieren > hochrechnen > und den Wert wieder zurück in den RAM kopieren

Dafür gibt es das LOCK, wo dann ein Speicherbereich für andere Kerne gesperrt wird.




Bei MultiThread mit mehreren Kernen mag das noch einfach sein, sowas innerhalb eines Chips/Prozessors zu behandeln.
PS: Vergesst nicht, dass früher auch nicht alles in der CPU drin war, sondern alles einzelne Funktionseinheiten/Chips die sich dann noch unterhalten müssten. (in Smartphons, Tablets, Schlepptops und vor allem MiniPCs sind CPU, FPU, NorthBridge, SouthBridge, GPIO, Speichercontroller, ... oft nur noch Eins)

Aber schlimmer wird es dann auch noch bei MultiCPU, also mehrere Kerne in mehreren Chips auf vielleicht auch noch mehreren verbundenen Boards.
Oder ganz modern, verteilte Rechenleitung über mehreren Rechenzentren.

In guten Cloudlösungen kannst Problemlos dein Programm in China laufen lassen und es mittendrin und ohne Unterbrechung nach Russland verschieben, in ein anderes Rechenzentrum deines Anbieters.

[himitsu]

Task = Thread+
Vielleicht besser erstmal klein anfangen, also direkt Threads.

Mit Tasks (Fiber im Windows-Jargon) wird es noch spaßiger,
da es Arbeitseinheiten sind, die wiederum in einem/mehreren Threads verarbeitet werden.

Man könnte Tasks sogar im Hauptthread ausführen lassen, womit es in der Programmierung wie MultiThread aussähe, aber eigentlich SingleThread wäre.