| Autor |
Beitrag |
wolke
      
Beiträge: 240
|
Verfasst: Fr 03.02.06 15:26
mal wieder was zu threads... ich habe mich eingelesen, gegoogled, hier gesucht aber irgendwie komme ich immer noch nicht weiter. ist ein wenig kompliziert zu erklären, dazu muss ich ein wenig ausholen.
folgendes problem: ich habe eine TList. jeder eintrag in dieser TList hat unter anderem eine StringList, in der alle rekursiv gefundenen dateien stehen.
mein kontrollthread soll diese liste verwalten, dh. neue einträge anlegen (Methode Add(pfad)). 'im hintergrund' sollen dann die dateien rekursiv gesucht werden.
diese TList-Einträge sollen (nachdem sie fertig gefüllt wurden) von diesem kontrollthread einzeln an einen abarbeitungsthread (Lesethread) gegeben werden, auf den ich dann warten will um ihm einen weiteren eintrag zu übergeben falls noch einer existiert und dieser fertig erstellt ist. falls kein eintrag mehr existiert soll der kontrollthread auf weiteren input warten, der LeseThread solange schlafen gelegt werden.
möglich wäre es auch, den LeseThread erst anzulegen, wenn
ich habe mir das also folgendermassen gedacht:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60:
| constructor TMainThread.Create; begin inherited Create(false);
Filelist := TFileList.Create; ReadThread := TReadThread.Create(true); ReadThread.Priority := tpIdle; ReadThread.FreeOnTerminate := false; end;
destructor TMainThread.Destroy; begin inherited Destroy; FileList.Free; ReadThread.Free; end;
procedure TMainThread.Execute; begin end;
procedure TMainThread.Add(pfad: string); begin FileList.Add(Pfad); end;
constructor TFilelistEntry.Create(const aFrom: string); begin self.FromString:=aFrom; self.fSize:=0; self.List := StringList.Create; self.addFiles(aFrom); self.Ready := true; end; |
ich weiß, ist ein wenig umfangreich, aber vielleicht könnt ihr mir trotzdem auf die sprünge helfen 
Zuletzt bearbeitet von wolke am So 05.02.06 09:58, insgesamt 2-mal bearbeitet
|
|
afk
      
Beiträge: 102
Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
|
Verfasst: Fr 03.02.06 16:36
Ich habe zwar nicht verstanden, was Du jetzt eigentlich wissen willst, aber einen Tip habe ich trotzdem:
TList und TStringList sind nicht thread-sicher, d.h. Du mußt Dich selbst darum kümmern, das sich Deine Threads nicht gegenseitig beim Zugriff auf die Listen stören.
Gruß Axel
_________________ Man muß sparn wo mn knn !
|
|
wolke 
      
Beiträge: 240
|
Verfasst: Fr 03.02.06 17:26
das ist mir klar
sorry, hab mich ein wenig unsauber ausgedrückt. was ich wissen will steht in den kommentaren im quellcode.
|
|
afk
      
Beiträge: 102
Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
|
Verfasst: Fr 03.02.06 22:10
Also ich glaube, ich habs immer noch nicht so ganz verstanden, aber ich probiere es trotzdem:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11:
| procedure TMainThread.Execute; begin end; |
Ja, TEvent ist meiner Meinung nach das richtige Instrument, und funktioniert nach dem gleichen Prinzip wie die Boolean.
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:
| procedure TMainThread.Add(pfad: string); begin FileList.Add(Pfad); end; |
Hier verstehe ich es nicht so ganz:
Wenn TMainThread.Add aufgerufen wird, dann soll TMainThread.Execute mit dem übergebenen Pfad die Arbeit aufnehmen und einen TReadThread erzeugen, der die Arbeit macht, richtig ?
Wenn währenddessen TMainThread.Add ein weiteres mal aufgerufen wird, soll dann von TMainThread.Execute ein zweiter TReadThread erzeugt werden ?
Wenn ja, dann darf die TMainThread.Execute nicht auf das Ende von TReadThread warten, denn sonst kann der zweite TReadThread ja erst erzeugt werden, wenn der Erste beendet ist, und dann wird das nichts mit dem parallelen abarbeiten der Liste.
Delphi-Quelltext 1: 2: 3: 4:
| self.addFiles(aFrom); self.Ready := true; |
Alles, was im Hintergrund passieren soll, gehört in einen eigenen Thread. Und TEvent habe ich oben schon erwähnt.
Weitere Fragen habe ich nicht entdeckt, ich hoffe das hilft weiter.
Gruß Axel
_________________ Man muß sparn wo mn knn !
|
|
wolke 
      
Beiträge: 240
|
Verfasst: Fr 03.02.06 22:59
danke nochmal.
es soll immer nur ein readthread existieren. was parallel passieren soll ist einerseits die abarbeitung dieser liste (einzelne einträge an readthread übergeben) und das rekursive füllen der einträge (MainThread.Add). es soll also einerseits gewartet werden bis der readthread mit einer datei fertig ist, um ihm eine weiter zu übergeben, währenddessen soll es aber möglich sein, neue einträge hinzuzufügen.
ich probier mich mal noch ein wenig mit rum, habe das ganze ein wenig anders gestaltet - readthread nimmt sich selbst elemente aus der filelist, MainThread.Execute wartet nur bis der ReadThread sich selbst beendet. aber ich probier da erstmal noch ein wenig rum und komme dann nochmal hierher zurück.
|
|
afk
      
Beiträge: 102
Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
|
Verfasst: Sa 04.02.06 00:31
wolke hat folgendes geschrieben: | | es soll also einerseits gewartet werden bis der readthread mit einer datei fertig ist, um ihm eine weiter zu übergeben, währenddessen soll es aber möglich sein, neue einträge hinzuzufügen. |
Dann solltest Du das Füllen der Liste mit neuen Einträgen in einen eigenen Thread packen, den du jeweils neu erzeugst, damit davon mehrere gleichzeitig laufen können.
Der ReadThread ist dafür dann überflüssig, das kann dann genausogut direkt im MainThread.Execute erfolgen, da der ja sowieso warten soll, bis der ReadThread fertig ist.
Gruß Axel
_________________ Man muß sparn wo mn knn !
|
|
wolke 
      
Beiträge: 240
|
Verfasst: Sa 04.02.06 00:51
ich will das irgendwie kapseln, deshalb hatte ich mir den MainThread überlegt. aber du hast recht, eigentlich isses unsinn.
wie mache ich es dann sinnvoll?
das habe ich bisher:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59:
| type TMainThread = class(TThread) private Filelist: TFileList; protected procedure Execute; override; public constructor Create; destructor Destroy; override; procedure AddFile(FileRecord: TFileRecord); end;
constructor TMainThread.Create; begin self.FreeOnTerminate:=false; inherited Create(true);
Filelist := TFileList.Create;
InitializeCriticalSection(CriticalSection);
end;
destructor TMainThread.Destroy; begin inherited Destroy; FileList.Free; DeleteCriticalSection(CriticalSection); end;
procedure TMainThread.Execute; var FileListEntry: TFileListEntry; begin FileListEntry:=nil; while not Terminated do begin EnterCriticalSection(CriticalSection); if filelist.count = 0 then begin LeaveCriticalSection(CriticalSection); break; end else begin FileListEntry:=Filelist.Items[0]; Filelist.DeleteReference(0); LeaveCriticalSection(CriticalSection); end; end; if Assigned(FileListEntry) then FileListEntry.Free; end;
procedure TMainThread.AddFile(FileRecord: TFileRecord); begin FileList.AddStringlist(FileRecord); end; |
du würdest also anstatt TMainThread.AddFile gleich einen komplett getrennten TThread erstellen?
irgendwie muss ich in TMainThread.Execute auch noch warten bis der nächste eintrag in der liste gültig ist, mit events habe ich mich noch nicht beschäftigt.
aber für heut ist es genug. mal schauen ob ich morgen dazu komme.
|
|
afk
      
Beiträge: 102
Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
|
Verfasst: Sa 04.02.06 01:19
wolke hat folgendes geschrieben: | du würdest also anstatt TMainThread.AddFile gleich einen komplett getrennten TThread erstellen?
irgendwie muss ich in TMainThread.Execute auch noch warten bis der nächste eintrag in der liste gültig ist, mit events habe ich mich noch nicht beschäftigt. |
Ist in dem Fall wahrscheinlich auch nicht nötig, Dich mit Events zu beschäftigen.
Ich hab zwar immer noch nicht den Teil des Codes gesehen, in dem der TFileListEntry erzeugt wird, aber dreh doch die Reihenfolge mal um:
In TMainThread.AddFile erzeugst und startest Du einen Thread, der dann einfach zuerst die Instanz von TFileListEntry erzeugt. Dabei wird die TStringList gefüllt, und erst danach wird der TFileListEntry von dem Thread zu deiner FileList hinzugefügt. Dann ist der Eintrag in der Liste sofort gültig und kann direkt vom Mainthread weiterverarbeitet werden (oder eben später, falls der MainThread noch beschäftigt ist).
Die Zugriffe auf die FileList mußt Du mit CriticalSections absichern, aber das kennst Du ja offensichtlich schon.
Gruß Axel
_________________ Man muß sparn wo mn knn !
|
|
wolke 
      
Beiträge: 240
|
Verfasst: Sa 04.02.06 20:25
sehr gute idee... wieso komm ich auf sowas nicht?
wenn ich in TMainThread.Execute die liste abarbeite muss ich ja trotzdem irgendwie darauf warten bis sie gefüllt ist, dh. einträge hat?
so wie ich mir das jetzt gedacht habe bleibt der thread auf suspend, bis ich ihn explizit resume (in dem thread in dem ich auch den eintrag erzeuge). sollte er alles abgearbeitet haben wird execute beendet, dh. der thread geht von selbst wieder in den suspend-zustand - ist das richtig so (wenn FreeOnTerminate=false)?
TFileListEntry-Erzeugung ist relativ uninteressant:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11:
| constructor TFilelistEntry.Create(const aFrom, aTo: widestring; const aAction: integer); begin self.FromString:=aFrom; self.ToString:=aTo; self.wFunc:=aAction; self.fSize:=0; self.List := TtntStringList.Create; self.addFiles(aFrom); end; |
wobei addFiles in etwa die bekannte rekursive dateisuche ist (FindFirstFileW/FindNextFileW).
wie kann ich denn sinnvoll den thread resumen, aus einem anderen thread heraus? das ist das was ich bisher habe, die stelle wo ich gerne resumen würde ist kommentiert.
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76: 77: 78: 79: 80: 81: 82: 83:
| constructor TMainThread.Create; begin self.FreeOnTerminate:=false; inherited Create(true);
Filelist := TFileList.Create; InitializeCriticalSection(CriticalSection); end;
destructor TMainThread.Destroy; begin FileList.Free; DeleteCriticalSection(CriticalSection); inherited Destroy; end;
procedure TMainThread.Execute; var FileListEntry: TFileListEntry; begin FileListEntry:=nil; while not Terminated do begin EnterCriticalSection(CriticalSection); if FileList.count = 0 then begin LeaveCriticalSection(CriticalSection); break; end else begin FileListEntry:=Filelist.Items[0]; FileList.DeleteReference(0); LeaveCriticalSection(CriticalSection); end; end; if Assigned(FileListEntry) then FileListEntry.Free; end;
procedure TMainThread.AddFile(FileRecord: TFileRecord); var AddEntry: TAddEntry; begin AddEntry:=TAddEntry.Create(FileRecord); end;
constructor TAddEntry.Create(NewFileRecord: TFileRecord); begin self.FileRecord := NewFileRecord; self.FreeOnTerminate:=true; inherited Create(false); end;
destructor TAddEntry.Destroy; begin FileRecord.Free; inherited Destroy; end;
procedure TAddEntry.Execute;
var count: integer; toString: WideString; begin with FileRecord do for count:=0 to Source.count-1 do begin if count< Destination.count-1 then toString := Destination.strings[count] else toString := Destination.strings[0];
FileListEntry := TFileListEntry.Create(Source.strings[count],toString,wFunc);
EnterCriticalSection(CriticalSection); FileList.Add(FileListEntry); LeaveCriticalSection(CriticalSection); if MainThread.Suspended then MainThread.Resume; end; end; |
edit: ah, ich glaube ich würde es jetzt so probieren: in TMainThread.AddFile per AddFile.WaitFor warten, danach MainThread.Resume. habe nur jetzt keine zeit mehr das auszuprobieren. wäre das richtig so?
|
|
afk
      
Beiträge: 102
Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
|
Verfasst: So 05.02.06 00:28
FreeOnTeerminate=False hat nur die Wirkung, das Dein Thread-Objekt nach Beendigung des Threads noch gültig bleibt, damit Du aus einem anderen Thread noch auf die Daten in Deinem Thread-Objekt zugreifen kannst. Der Thread selbst ist nach dem Verlassen von Execute aber definitiv beendet und nicht suspended.
Entweder mußt Du den MainThread permanent laufen lassen, nur das der außer einem Sleep(x) nichts tut, solange sich kein Eintrag in der Liste befindet, oder Du must den MainThread innerhalb der Execute-Methode immer dann mit Suspend "schlafen legen", wenn es gerade nichts für ihn zu tun gibt. Im zweiten Fall mußt Du den Thread dann aber von außen (aus einem anderen Thread heraus) mit Resume wieder "aufwecken", was Du dir im ersten Fall sparen kannst.
Gruß Axel
_________________ Man muß sparn wo mn knn !
|
|
wolke 
      
Beiträge: 240
|
Verfasst: Mo 06.02.06 01:57
ich habe noch weiter rumexperimentiert und es scheint (bis auf ein kleines speicherleck, siehe anderer thread) immer mehr zu funktionieren! habe gerade noch einen fehler gefunden über den ich lange gegrübelt habe, aber langsam komme ich rein in die materie.
mein problem war folgender code:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10:
| procedure TFileCopy.AddFile(FileRecord: TFileRecord); var AddEntry: TAddEntry; begin AddEntry := TAddEntry.Create(FileRecord); AddEntry.WaitFor; if self.Suspended then self.Resume; end; |
wenn ich statt der if-abfrage einfach nur self.Resume schreibe funktioniert es.
irgendwo sind noch andere bugs versteckt, aber den rest suche ich morgen. zum beispiel darf ich meine anwendung in gewissen fällen nicht mehr schliessen, sie bleibt einfach hängen wenn ich auf das schliessen-symbol klicke.
|
|
wolke 
      
Beiträge: 240
|
Verfasst: Mo 06.02.06 21:34
so ists aber doch auch idiotisch - MainThread.AddFiles soll ja gar nicht darauf warten daß eingekettet wurde, der soll ja parallel noch arbeiten können.
eigentlich wäre es ja sinnvoll, den MainThread dann in AddEntry zu resumen wenn ein eintrag eingehängt wurde. von dort aus habe ich aber ja keinen zugriff auf die instanz?
ich habe das jetzt mal folgendermaßen gelöst, ist das ein sauberer weg?
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25:
| procedure TMainThread.AddFile(FileRecord: TFileRecord); var AddEntry: TAddEntry; begin AddEntry := TAddEntry.Create(FileRecord, self); end;
constructor TAddEntry.Create(NewFileRecord: TFileRecord; MainThread: TFileCopy); begin self.FileRecord := NewFileRecord; self.MainThread := MainThread; self.FreeOnTerminate:=true; self.Priority := tpIdle; inherited Create(false); end;
procedure TAddEntry.Execute;
begin FileListEntry := TFileListEntry.Create(FileRecord); EnterCriticalSection(CriticalSection); FileList.Add(FileListEntry); LeaveCriticalSection(CriticalSection); if MainThread.suspended then MainThread.Resume; end; |
|
|
afk
      
Beiträge: 102
Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
|
Verfasst: Mo 06.02.06 23:48
Das trifft's meiner Meinung nach schon ziemlich gut, ist auch sauber implementiert (würde ich wohl auch so machen  ), ich hab nur einen noch kleinen Tipp:
Da Du den Suspend vom MainThread nicht mit in die CriticalSection aufnehmen kannst (hat sonst einen DeadLock zur Folge !), solltest Du zur Sicherheit noch einen kurzen Sleep(X) vor der Abfrage, ob der MainThread noch läuft, in der AddEntry.Execute einfügen. Bei einem Thread-Wechsel direkt vor dem Suspend kann es sonst passieren, das sich der MainThread mit einem gerade hinzugekommenen Eintrag "schlafen legt".
Gruß Axel
PS: Nur mal so aus Neugier: Was für ein Programm schreibst Du eigentlich ?
_________________ Man muß sparn wo mn knn !
|
|
wolke 
      
Beiträge: 240
|
Verfasst: Di 07.02.06 14:45
das klingt ja schonmal ganz gut, aber so richtig verstehe ich nicht was das hilft. kann denn nicht der threadwechsel direkt vor dem sleep bzw. danach erfolgen? oder meinst du ich soll das sleep mit in die critical section packen?
was das genau wird soll an dieser stelle noch nicht verraten werden - laß dich überraschen *g*
aber ich würde gerne gleich eine frage anschliessen (hoffe das geht klar, paßt ja thematisch hier dazu und der kontext ist ja evtl auch wichtig): der mainthread wird bei programmstart erschaffen, soll bis zum programmende existieren und dann entfernt werden. so habe ich es jetzt bisher gelöst, irgendwie ist das aber unsauber:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38:
| procedure TMainThread.Execute; var FileListEntry: TFileListEntry; begin while not Terminated do begin EnterCriticalSection(CriticalSection); while (FileList.count = 0) do begin LeaveCriticalSection(CriticalSection); if Terminated then exit; self.Suspend; EnterCriticalSection(CriticalSection); end;
FileListEntry:=Filelist.Items[0]; FileList.DeleteReference(0); LeaveCriticalSection(CriticalSection);
FileListEntry.Free; end; end;
procedure TForm1.FormCreate(Sender: TObject); begin FileCopy := TFileCopy.Create; end;
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin FileCopy.Terminate; FileCopy.Resume; WaitForSingleObject(FileCopy.Handle,5000); FileCopy.Free; end; |
Im Falle daß sich der Thread nicht beendet warte ich 5 Sekunden - währenddessen steht mein ganzes Programm, unschön. Wieder in einen extra Thread auslagern? Oder wie löse ich das sauber? Wenn ich nur FileCopy.Free aufrufe friert mein Programm komplett ein.
|
|
afk
      
Beiträge: 102
Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
|
Verfasst: Di 07.02.06 15:11
Mal folgenden Ablauf angenommen:
-> MainThread tritt in die CriticalSection ein
-> checked die Liste: Liste ist leer
-> CriticalSection wird verlassen
-> und jetzt schlägt der Threadwechsel zu
-> AddEntry tritt in die CriticalSection ein
-> neuer Eintrag wird zur Liste hinzugefügt
-> CriticalSection wird verlassen (*)
-> checked den MainThread: MainThread läuft
-> MainThread wird nicht resumed
-> ...
-> und wieder ein ThreadWechsel
-> MainThread suspended sich selbst (trotz neuem Eintrag)
Das kannst Du durch einen Sleep(X) verhindern an (*) verhindern, der Sleep automatisch die Ausführung an die anderen (wartenden) Threads abgibt. Dadurch suspended sich der MainThread bevor in AddEntry abgefragt wird, ob er noch läuft.
Gruß Axel
_________________ Man muß sparn wo mn knn !
|
|
afk
      
Beiträge: 102
Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
|
Verfasst: Di 07.02.06 15:20
Zweiten Teil der Frage übersehen (Browser zu langsam  ):
Das kannst Du nur sauber lösen, indem du dafür sorgst, daß Dein Thread sich nach dem Terminate auch möglichst schnell beendet.
Also so oft wie möglich Terminated abfragen und entsprechend reagieren ...
Gruß Axel
_________________ Man muß sparn wo mn knn !
|
|
wolke 
      
Beiträge: 240
|
Verfasst: Di 07.02.06 18:50
ah, ok, sleep gibt also ab an den anderen thread. macht sinn.  mit sleep(0) den rest vom timeslice abzugeben reicht nicht, oder?
ansonsten ist das sauber so, mit waitforsingleobject?
|
|
afk
      
Beiträge: 102
Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
|
Verfasst: Mi 08.02.06 10:05
Sleep(0) sollte in diesem Fall reichen, da der MainThread direkt nach dem Verlassen der CritticalSection sich selbst Suspended, also ein Problem nur auftreten kann, wenn er genau dazwischen unterbrochen wird. Da die Stelle des Sleep im AddEntry aber völlig zeitunkritisch ist, kannst Du zur Sicherheit auch einen größeren Wert wählen, der AddEntry-Thread wird dann eben dementsprechend später beendet.
Was den WaitForSingleObject angeht, da mußt Du Dir noch Gedanken machen, was passiert wenn sich der Thread nicht innerhalb der 5 Sekunden beendet. Evtl. einfach mal ausprobieren.
Gruß Axel
_________________ Man muß sparn wo mn knn !
|
|
|