Autor Beitrag
wolke
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 240



BeitragVerfasst: 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:

ausblenden volle Höhe 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:
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;
 // die Filelist hat einträge; jeder eintrag hat eine StringList

 ReadThread := TReadThread.Create(true);
 ReadThread.Priority := tpIdle;
 ReadThread.FreeOnTerminate := false;
 // der lesethread soll erst angeschmissen werden wenn der nutzer TMainThread.Add verwendet hat
end;

destructor TMainThread.Destroy;
begin
 inherited Destroy;
 FileList.Free;
 ReadThread.Free;
end;

procedure TMainThread.Execute;
begin
 // hier soll MainThread darauf warten, daß ein gültiger eintrag in der Filelist
 // steht; bisher setze ich nach dem rekursiven Filelist.Add eine boolean-variable
 // wie warte ich effizient auf einen gültigen eintrag? events? blick ich 
 // irgendwie nicht durch

 // ist ein gültiger eintrag da, soll der ReadThread angeworfen werden, als 
 // parameter die erste Datei des Eintrags
 // danach auf ReadThread warten und ihm neue dateien nachreichen, bis keine 
 // einträge mehr in FileList -> dann wieder auf neue einträge warten
end;

procedure TMainThread.Add(pfad: string);
begin
 FileList.Add(Pfad);
 // FileList soll im hintergrund rekursiv alle dateien suchen
 // im moment blockiert diese methode den kompletten MainThread
 
 // falls während der rekursiven abarbeitung noch ein neuer aufruf
 // von TMainThread.Add erfolgt, sollen parallel mehrere verzeichnisse
 // durchsucht werden, also neue einträge in der TList erzeugt werden
 // - das sollte aber unproblematisch funktionieren (arbeiten ja 
 // getrennt in unterscheidlichen einträgen)
end;

{ ************************************************************************ }

constructor TFilelistEntry.Create(const aFrom: string);
begin
 self.FromString:=aFrom;
 self.fSize:=0; // akkumulierte größe des ordners; Int64

 self.List := StringList.Create;
 self.addFiles(aFrom); // rekursives hinzufügen! das hier muss noch irgendwie im hintergrund passieren!

 self.Ready := true; 
 // signalisiert dem MainThread, daß Eintrag 'fertig' und somit gültig -> glaube nicht daß das die sauberste
 // methode ist
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
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 102

Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
BeitragVerfasst: 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 Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 240



BeitragVerfasst: 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
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 102

Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
BeitragVerfasst: Fr 03.02.06 22:10 
Also ich glaube, ich habs immer noch nicht so ganz verstanden, aber ich probiere es trotzdem:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
procedure TMainThread.Execute;
begin
 // hier soll MainThread darauf warten, daß ein gültiger eintrag in der Filelist
 // steht; bisher setze ich nach dem rekursiven Filelist.Add eine boolean-variable
 // wie warte ich effizient auf einen gültigen eintrag? events? blick ich 
 // irgendwie nicht durch
 // ist ein gültiger eintrag da, soll der ReadThread angeworfen werden, als 
 // parameter die erste Datei des Eintrags
 // danach auf ReadThread warten und ihm neue dateien nachreichen, bis keine 
 // einträge mehr in FileList -> dann wieder auf neue einträge warten
end;

Ja, TEvent ist meiner Meinung nach das richtige Instrument, und funktioniert nach dem gleichen Prinzip wie die Boolean.

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
procedure TMainThread.Add(pfad: string);
begin
 FileList.Add(Pfad);
 // FileList soll im hintergrund rekursiv alle dateien suchen
 // im moment blockiert diese methode den kompletten MainThread
 
 // falls während der rekursiven abarbeitung noch ein neuer aufruf
 // von TMainThread.Add erfolgt, sollen parallel mehrere verzeichnisse
 // durchsucht werden, also neue einträge in der TList erzeugt werden
 // - das sollte aber unproblematisch funktionieren (arbeiten ja 
 // getrennt in unterscheidlichen einträgen)
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.

ausblenden Delphi-Quelltext
1:
2:
3:
4:
 self.addFiles(aFrom); // rekursives hinzufügen! das hier muss noch irgendwie im hintergrund passieren!
 self.Ready := true; 
 // signalisiert dem MainThread, daß Eintrag 'fertig' und somit gültig -> glaube nicht daß das die sauberste
 // methode ist

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 Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 240



BeitragVerfasst: 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
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 102

Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
BeitragVerfasst: Sa 04.02.06 00:31 
user profile iconwolke 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 Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 240



BeitragVerfasst: 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:

ausblenden volle Höhe 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:
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);
    
    { ab hier irgendwas mit FileListEntry.List anstellen }
   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
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 102

Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
BeitragVerfasst: Sa 04.02.06 01:19 
user profile iconwolke 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. :wink:

Gruß Axel

_________________
Man muß sparn wo mn knn !
wolke Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 240



BeitragVerfasst: 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:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
{ create filelist entry }
constructor TFilelistEntry.Create(const aFrom, aTo: widestring; const aAction: integer);
begin
 self.FromString:=aFrom;
 self.ToString:=aTo;
 self.wFunc:=aAction;
 self.fSize:=0;
// create stringlist, recursively add all files
 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.

ausblenden volle Höhe 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:
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);

 // initialize FileList
 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);
    // beginning here, we have the responsibility to
    // do something with FileListEntry ;)
    // {.... }
   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;
{ adds a filerecord to the list, consisting of Source, Destination and action }
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);
   // now at least one valid filelist entry exists, resume worker thread
   if MainThread.Suspended then MainThread.Resume; // <--- das funzt natürlich nicht
 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
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 102

Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
BeitragVerfasst: 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 Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 240



BeitragVerfasst: 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:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
procedure TFileCopy.AddFile(FileRecord: TFileRecord);
var AddEntry: TAddEntry;
begin
// erzeuge neuen thread, dieser fügt alle gefundenen dateien in die TFileList ein
 AddEntry := TAddEntry.Create(FileRecord);
 AddEntry.WaitFor;
// hier ist sichergestellt, daß ein gültiger eintrag in der filelist existiert
// also thread resumen, falls er suspended ist
 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 Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 240



BeitragVerfasst: 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?

ausblenden 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
 // FileEntry erzeugen (rekursiv dateien suchen), einketten in FileList
 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;
{ adds a filerecord to the list }
begin
  FileListEntry := TFileListEntry.Create(FileRecord);
  EnterCriticalSection(CriticalSection);
  FileList.Add(FileListEntry);
  LeaveCriticalSection(CriticalSection);
  if MainThread.suspended then MainThread.Resume;
end;
afk
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 102

Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
BeitragVerfasst: 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 :wink:), 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 Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 240



BeitragVerfasst: 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:

ausblenden volle Höhe 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:
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 // while-schleife zum terminieren
   begin
      LeaveCriticalSection(CriticalSection);
      if Terminated then exit;
      self.Suspend;
      EnterCriticalSection(CriticalSection);
   end;

    FileListEntry:=Filelist.Items[0];
    FileList.DeleteReference(0);
    LeaveCriticalSection(CriticalSection);

    // ab hier was mit dem Entry anstellen
    // [...]
    // zum schluss freigeben:

    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
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 102

Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
BeitragVerfasst: 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
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 102

Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
BeitragVerfasst: Di 07.02.06 15:20 
Zweiten Teil der Frage übersehen (Browser zu langsam :roll:):

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 Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 240



BeitragVerfasst: 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
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 102

Win 2K, Win XP
Delphi 2006 Arch., Delphi 6 Ent., MS-SQL 2005 & 2000
BeitragVerfasst: 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 !