Also:

Ich habe eine ChecklistBox, wo alle Festplatten/Partitionen aufgelistet werden.

Dann habe ich einen Record:

markieren

Delphi-Quellcode:

type
  TSelectedDrives = record
    Drive: string;
    Selected: Boolean;
  end;

Und davon dann natürlich einen Array, der so lang ist, wie es Festplatten/Partitionen gibt.

Mit einer Schleife überprüfe ich dann, welche Laufwerke ausgewählt sind (checked) und setzte dann im Array "Selected" auf true.

Das funktioniert alles 100% richtig.

Dann habe ich noch die Klasse TSearchThread mit folgender Execute-Prozedure und folgendem Create-Constructor:

zusammenfalten · markieren

Delphi-Quellcode:

constructor TSearchThread.Create(path:string);
begin
   fpath:=path;
   inherited Create(true);
end;

procedure TSearchThread.Execute;
  var
i:integer;
liste: TStringList;
begin
   liste := TStringList.Create;
   GetFilesInDirectory(fpath,'*.exe',liste,true,true); // Funktion hier aus der CodeLibary
   frmSearchdlg.Memo1.Lines.AddStrings(liste);
   liste.Free;
end;

Ja ich müsste eigentlich mit Synchronize arbeiten, aber das tut jetzt ja nichts zur Sache...

Dann habe ich noch einen Thread der dann alle SearchTreads nacheinander ausführen soll (s. obere Posts).

Und natürlich noch der Code für den SearchThread-Array:

markieren

Delphi-Quellcode:

SetLength(SearchThread,0);
   for i := 0 to Length(SelectedDrives) - 1 do begin
     if SelectedDrives[i].Selected then begin
       SetLength(SearchThread,Length(SearchThread)+1);
       SearchThread[Length(SearchThread)-1] := TSearchThread.Create(SelectedDrives[i].Drive);
       SearchThread[Length(SearchThread)-1].OnTerminate := ThreadTerminateProc;
     end;
   end;
   Threads := TThreads.Create(false); // Dieser Thread macht dann SearchThread[i].Resume
   Threads.FreeOnTerminate := true;

Der SearchThread-Array ist auch korrekt. Wie gesagt, wird aber immer nur der letzte von allen SearchThreads ausgeführt.

und wie sieht die Execute-Methode von deinem TThreads aus? Auch die ThreadTerminateProc währe interessant. Im prinzip hast du ja nur den Source gepostet welcher die Threads creiert aber nicht den relevanten source welcher zeigt wie du nach Beendigung (ThreadTerminateProc) den nächsten Thread startest und auch nicht wie du dir merkst welches der nächste Thread ist (TThreads.Execute?)

Im übrigen hab ich hier noch einen Fehler gefunden:

markieren

Delphi-Quellcode:

Threads := TThreads.Create(false); // Dieser Thread macht dann SearchThread[i].Resume
Threads.FreeOnTerminate := true;

Diese stelle ist recht riskannt. Denn du startest den Thread und setzt danach erst "FreeOnTerminate := true". Theoretich kann zu diesem Zeitpunkt der Thread aber schon abgearbeitet sein.

Der Code, der dir nun fehlt, ist der, den du gepostet hast.

Ich habe deinen letzten Code verwendet und damit wird nur der letzte ausgeführt. Die anderen Codes habe ich nicht, da überschrieben.

Aber z.B. bei Post #5 Habe ich den Code von Threads.Execute.

Ich habe dort schon alles ausprobiert. von while über repeat until. Und habe da Überprüfung gemacht, ob der Thread1 beendet ist oder einen ReturnValue zurück gibt bevor er weiter machen darf. Habe dort mit WaitForSingleObject gearbeitet. Einfach ALLES.

Es werden auch ALLE Threads gestartet, aber es werden ALLE bis auf den letzten auch sofort wieder beendet, ohne dass deren Execute ausgeführt wird. Das versteh ich einfach nicht.

edit:

vielleicht sollte ich einfach das hier:

markieren

Delphi-Quellcode:

procedure TSearchThread.Execute;
  var
i:integer;
liste: TStringList;
begin
   liste := TStringList.Create;
   GetFilesInDirectory(fpath,'*.exe',liste,true,true); // Funktion hier aus der CodeLibary
   frmSearchdlg.Memo1.Lines.AddStrings(liste);
   liste.Free;
end;

dahingehend abändern, dass ich nicht nur ein Laufwerk übergebe, sondern die Liste mit allen ausgewählen Laufwerken und dann dort eine Schleife einbaue, die dann nacheinander alle Laufwerke durchsucht. Dann bräuchte ich auch nur noch einen Thread und keinen Array..

der Source von Post#5 passt ja aber nicht zu der OnTerminate-Methode. Denn bei Post5 startest du die Threads in einer Schleife. Bei der OnTerminateMethode wird der nächste Thread eben im OnTerminate gestartet. Zudem brauchst du dann eigentlich die klasse TThreads nicht.

Im übrigen finde ich die Methode mit einem Thread (also ohne Array) bedeutend sinnvoller. Auch die Aktuallisierung des Memos solltest du syncron durchführen (ansonsten kommen teilweise unerklärliche fehler).

Beides gleichzeitig habe ich nicht genutzt. Ich habe einmal deinen Code ausprobiert mit OnTerminate und davor hatte ich eine ganz andere Variante (#5).

"Threads" ist dadurch entstanden, dass ich vor über die Hauptanwendung mit einer Schleife alle SearchThreads nacheinander abarbeiten wollte und dort dann auch mit WaitFor bzw. WaitForSingleObject gearbeitet habe. Dadurch fror aber während der Suche die Hauptanwendung ein. Das habe ich ganz oben auch geschrieben.

edit:

ja das werde ich nun auch wohl so machen. Das mit Synchronize habe ich ja oben auch geschrieben, dass ich das weiß und noch mache

Danke für deine Mühen

ich hab das mit dem Syncronize nur nochmal geschrieben um zu verdeutlichen das dein Fehler eventuell auch daher kommt (weil eben ohne Syncronisierung teilweise unerklärliche Dinge passieren). Wobei mich schon wundert das die Methode mit den Arrays nicht funktioniert. Da aber die Variante mit einem Thread bedeutend sinnvoller ist, ist es überflüssig da den Fehler weiter zu suchen anstelle das ganze sinnvoll umzubauen (eben auf einen Thread)