TThread vs. TObject bzw. gleichzeitig vs. nacheinander

[Angel4585]

Hallo zusammen

Ich habe im moment noch kA von Threads und hab daher bisher alles mit Objects gemacht.

Jetzt will ich mal die Unterschiede der beiden wissen.

Also einer ist das Threads gleichzeitig Befehle ausführen können.
Also

Thread1 ruft prozedure x auf

zur selben zeit

ruft Thread2 prozedur Y auf

bei zwei Threads passiert das ganze Zeitgleich, bei Objects nacheinander, oder versteh ich das falsch?

Mfg Angel4585

[Robert_G]

Wenn du mit Objects Klassen meinst, kann ich dich beruhigen. TThread sieht für veflucht nach einer Klasse aus. ;)

Du vergleichst hier übrigens Äpfel mit tibetanischen Gebirgsziegen:
Beide Begriffe haben recht herzlich wenig miteinander zu tun. Threads erlauben es dir mehrere Abläufe gleichzeitig auszuführen.
Ob du deinen Code nun prozedural oder objekt-orientiert schreibst interessiert deine Threads wenig.

Bevor du dich mit Threads anlegst, sollte der Rest glasklar sein.
Multi threaded zu programmieren gehört sicherlich nicht zu den einfachsten Dingen. ;)

[Angel4585]

Ja, TThread ist eine Klasse, genauso wie TObject.

Wenn ich jetzt zwei neue Klassen ableite, heisst das bei Threads also das es automatisch "läuft"(Edit: bis ein bestimmter Zustand eintrifft) und ich nicht irgendwie einen Timer oder so brauche der mir alle paar Millisekunden eine Prozedur aufruft, oder?

Wieviele Threads kann man eigentlich gleichzeitig erstellen?

Luckie ist doch hier der Threadexperte oder?

[neolithos]

TThread ist eine "schöne" Klasse, die die Thread-Api kapselt. Aber das Thema Thread hat rein gar nichts mit Klassen/Objekten/Proceduren im engeren Sinne zu tun.

Thread (zu dt. Faden) ist ein Programweg innerhalb des Processen (deiner Anwendung). Alles was im Context (als im Bereich) des Threads ausgeführt wird, ist nebenläufig (quasi Parallel) zu den anderen Threads in deinem Process.

Erstmal einen Kurzeinführung zu den Klasse Thread: Es gibt die wichtigen Methoden Execute, Suspend, Resume.

Execute:
Ist die Einstiegsmethode des Threads. Alles was hier gerufen wird oder getan läuft in diesem Thread ab. Wird diese Methode verlassen wird dieser Thread zu einem Zombie.

Suspend:
Stoppt die Ausführung eines Threads. Sie kann aber mittels...

Resume:
... später wieder fortgesetzt werden.


Nun zu der schlechten Nachricht; Threadprogrammierung ist keine banale Sache die man einfach mal so schnell lernen kann und es gibt Leute, die es meiner bescheidenen Meinung nach bis heute noch nicht begriffen haben. Aber nicht den Mut verlieren. Meine Meinung zählt sowieso nie :( :

Konzepte, die wichtig sind:
- Speicherverhalten
- Sperren (CriticalSection als erstes, der Rest ist für den Anfang nicht so wichtig -> Mutex, Semaphore)
- Nachrichten in Windows
- Synchronization
- Prioritäten
- Dead Locks

Eve. Nützliche Links:
http://www.luckie-online.de/Develope...mit_Delphi.pdf
http://hsg.region-kaiserslautern.de/...eads/index.php
http://www.dsdt.info/tutorials/threads/´
http://wiki.delphigl.com/index.php/T...Multithreading



btw.: Soviele wie das Betriebssystem verträgt. Bei WinXP eine riesen Anzahl. Es kommt immer darauf an wie sich die Threads veralten.

btw2.: So wie ich das sehe hast du das Thema Thread noch nicht verstanden, mach dich erstmal damit vertraut, bevor die ins blaue Schießt.

[Angel4585]

Also so schwer wie du sagst ist das doch garnicht, oder?

Also ich habe einen Thread:

Delphi-Quellcode:

TMyThread =class(TThread)
 private
 protected
  procedure Execute;override;
 public
 end;

eine Variable vom Typ TMyThread

Delphi-Quellcode:

MyThread : TMyThread;

und Mit folgender Zeile kann ich das ganze starten:

Delphi-Quellcode:

MyThread := TMyThread.Create(True);
MyThread.Resume;

in Execute steht z.B. folgendes:

Delphi-Quellcode:

procedure TMyThread.Execute;
begin
while not Terminated do
 begin
 sleep(10);//Damit der Rechner nicht komplett ausgelastet ist
 Synchronize(Prozedur)//Prozedur aufrufen 
 end;
end;

(Bis jetzt war das ein kinderspiel) :stupid:
Was muss man jetzt noch wissen? :gruebel:

Ach ja man kann noch nen Konstruktor integrieren:

Delphi-Quellcode:

TMyThread =class(TThread)
 private
 protected
  procedure Execute;override;
 public
  constructor Create(x,y,z : integer);
 end;
.
.
.

constructor TMyThread.Create(x,y,z : integer);
begin
inherited Create(True);
end;

Aufruf ist dann folgender:

Delphi-Quellcode:

MyThread := TMyThread.Create(1,2,3);
MyThread.Resume;

[neolithos]

Kompliziert wird es wie schon, aber eve. nicht deutlich genug, gesagt, wenn gemeinsam genutzte Speicherbereiche ins Spiel kommen. Variablen auf die von unterschiedlichen Threads zugegriffen wird. Oder es um Rangfolgen geht.

Du hast aber schon die Spitze des Eisberges entdeckt. Es gibt aber noch viel zu entdecken. Oder wie die hier sagen: "dive into it".

[Angel4585]

:thumb:

Jetzt wo du das so sagst denk ich mir irgendwie das man ne Sektion im Forum eröffnen sollte in denen solche grundlegenden Befehle bzw. der grundsätzliche Umgang für einzelne Klassen auf die Art wie ich es oben gemacht habe beschrieben werden sollte, also fast nur Quelltext und keine langen Romane wie es in den meisten Tutorials der Fall ist. Das würde echt weiterhelfen.

[Der_Unwissende]

Sorry, aber wem genau sollte das helfen?
Ich denke der Sinn eines Forums ist es gerade Tutorials mit Text zu füllen, so dass Leute die es lesen verstehen warum etwas gemacht wird.
Wenn hier jmd. der schon etwas (viel) weiter als du ist, was Threads angeht, hier eins seiner Programme postet, dann steigt doch einfach mal keiner durch.

Also mag ja sein, dass du jetzt hier ganz toll einen Thread erzeugt hast, aber denkst du denn, dass jetzt jmd. weiß warum du den mit MyThread.Create(True) anlegst? Also klar, man kann jetzt in die Hilfe schauen, aber mal ehrlich, eine Zeile Kommentar...
Jedenfalls wird gerade Threading sehr schnell sehr viel Komplizierter als das was du hier als Code gepostet hast. Was dir vielleicht noch gar nicht klar ist, ist wie kompliziert das Threading noch werden kann. So kann es zu einer Verklemmung kommen, die 100000 (nicht übertrieben) nicht auftritt, aber beim 100001ten mal.
Und einfach nur ein großes Stück Code, dass aus mehreren Klassen besteht, die irgendwelche Abhängigkeiten haben und auf gemeinsame Speicherbereiche zugreifen, na ja, wem hilft dass denn? Der Sinn ist es doch letztlich etwas verstanden zu haben und das geht nun mal nicht ohne den Text, der einfach mal erklärt warum man was macht.

Gruß Der Unwissende

[Angel4585]

Ne Zeile Kommentar mein ich ja garnicht.Klar kann man das reinschreiben und es ist auch sinnvoll. Allerdings wenn jemand nen Text von 10 Zeilen über den Hintergrund von Delphi schreibt ist das finde ich übertrieben. Man sollte die Sektion auch nur neben den Tutorials anlegen, für die etwas fortgeschritteneren User, die nur nochmal kurz sich die Syntax anschauen wollen.

Ich finde die ausführlichen Tutorials für den Anfänger schon sehr hilfreich, nur wenn man jetzt schon 2 Jahre programmiert und eben die Standardsachen kennt ist es manchmal nervig wenn da noch ellenlanger Text steht und es wäre in dieser Situation prktisch wenn man nur solchen Code hat

[Der_Unwissende]

Zitat:

Zitat von Angel4585

..., für die etwas fortgeschritteneren User, die nur nochmal kurz sich die Syntax anschauen wollen.

Hm, gute Idee. Ich glaube es wäre ja dann super, wenn Quellcode einfach als solcher markiert werden würde, dann kann ja der etwas fortgeschrittene Benutzer direkt an diese Stellen springen und der noch nicht so fortgeschrittene einfach zusätzlich den Text lesen. Aber hey, das gibt es ja schon :wink: