Hey danke nochmal für die vielen Antworten, ich hab es jetzt mal (trotz allen bedenken) mit einem Thread-Objekt (noch etwas unfertig) gemacht. Das ganze wird so in einem Bruchteil erledigt. Hier mal der Code.
Wie gesagt noch nicht ganz fertig... Wie kann man die Zeit von dem ganzen Ablauf Messen ? Vorher habe ich das mit dem QueryPerformanceCounter gemacht in der ButtonClick Prozedur. Aber die Threads verfälchen das ganze doch ?
Schneller ist es aufjedenfall, das sehe ich schon allein wie schnell der Output da ist.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyThread1 = class (TThread)
    private
    protected
      procedure Execute; override;
     public
       FDateienname: String;
  end;

{ MyThread1 }

procedure TMyThread1.Execute;
var
  AProcess: TProcess;
begin
  AProcess := TProcess.Create(nil);
  try
    AProcess.Executable := ExtractFilePath(application.ExeName)+'Umwandler.exe';
    AProcess.Parameters.Add(FDateienname);
    AProcess.Options := AProcess.Options + [poWaitOnExit, poNoConsole];
    AProcess.Execute;
  finally
    AProcess.Free;
  end;
end;


procedure TForm1.Button8Click(Sender: TObject);
var
  DateienLst: TSearchRec;
  Thread1: TMyThread1;
begin
  if FindFirst(Directory + '*.txt', faAnyFile and not faDirectory, DateienLst) = 0 then
    try
      repeat
        Thread1:= TMyThread1.Create(True);
        Thread1.FDateienname:= Directory+DateienLst.Name;
        Thread1.Resume;
      until FindNext(DateienLst) <> 0;

      Thread1.FreeOnTerminate := True //??
    finally
      SysUtils.FindClose(DateienLst);
    end;
end;

Ja, der Unterschied ist jetzt, dass du nicht mehr auf Beendigung der Threads wartest.

Ich weiß nicht, ob du das wirklich wolltest?

Nein wollte ich nicht. Aber anders ist die erste Version immer abgestürzt....

Das FreeOnTerminate gehört in die Schleife, sonst gilt es nur für die als letztes erzeugte Thread-Instanz.

Zitat von Ginko:

zusammenfalten · markieren

Delphi-Quellcode:

    try
      repeat
        Thread1:= TMyThread1.Create(True);
        Thread1.FreeOnTerminate := True //Wenn schon, dann gehört das hier hin.
        Thread1.FDateienname:= Directory+DateienLst.Name;
        Thread1.Resume;
      until FindNext(DateienLst) <> 0;

    finally
      SysUtils.FindClose(DateienLst);
    end;
end;

Du erzeugst jetzt für jede gefundene Datei einen Thread - das ist bei vielen Dateien auch wieder nicht optimal.

Daß du nicht auf das Ende der jeweiligen Threads wartest, wurde ja schon gesagt.

Zitat von Uwe Raabe:

Du erzeugst jetzt für jede gefundene Datei einen Thread - das ist bei vielenDateien auch wieder nicht optimal.

Ja das war eigentlich auch nur ein erster Versuch überhaupt das ganze mit Threads zum laufen zu bringen. Ich hatte auch vor die Anzahl zu beschränken, im Taskmanager sieht das so aber sehr lustig aus....

Stand nicht irgend wann mal in einer Delphi Docu, dass mehr als 16 Thread es langsammer machen?

Mavarik

Ja, und da steht auch drin, dass man mindestens 90MHz auf seiner CPU haben sollte wenn seine Form transparent machen möchte.

Ich höre öfter mal 1-1,5 mal Anzahl Kerne als Grenzwert, das hängt aber sicher von der Aufgabe und dem System ab.
Das Optimum ist da nur heuristisch zu ermitteln.

Für jede Datei einen Thread zu Erstellen ist aber höchstwahrscheinlich der falsche Weg.
Anstelle von der Anzahl der Ressourcen (Kerne, evtl. Platten/Partitionen), welche die "ideale" Anzahl von Threads bestimmen, lässt du die Anzahl der Aufgaben diese Entscheidung treffen, die damit nichts zu tun hat und vermutlich auch noch vom arglosen User vorgegeben wird.

Zu viele Threads kosten Zeit für die Erstellung (wenn du keinen Pool benutzt), Zeit für die Threadwechsel und nicht zu vergessen: das Dateisystem (und das Gesamtsystem allgemein) wird auch nicht gerade effizienter, je mehr Threads darauf herumhacken.

Gibt es einen Weg die Dauer des gesamten Vorgangs zu messen ?

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Button8Click(Sender: TObject);
var
  DateienLst: TSearchRec;
  Thread1: TMyThread1;
  //Zeittest
  freq: Int64;
  startTime: Int64;
  endTime: Int64;
begin
  QueryPerformanceFrequency(freq);
  QueryPerformanceCounter(startTime);

  if FindFirst(Directory + '*.txt', faAnyFile and not faDirectory, DateienLst) = 0 then
    try
      repeat
        Thread1:= TMyThread1.Create(True);
        Thread1.FreeOnTerminate := True;
        Thread1.FDateienname:= Directory+DateienLst.Name;
        Thread1.Resume;
      until FindNext(DateienLst) <> 0;

    finally
      SysUtils.FindClose(DateienLst);
    end;

  QueryPerformanceCounter(endTime);
  ShowMessage('Die Routine benötigte etwa ' + IntToStr((endTime - startTime) * 1000 div freq) + 'ms');
end;

Der Wert der hier raus kommt deckt sich ja nicht mit der Gesamtdauer, da die Threads ja unabhängig laufen oder ?

Zitat von Mavarik:

Stand nicht irgend wann mal in einer Delphi Docu, dass mehr als 16 Thread es langsammer machen?

Für mehr Threads als die Anzahl der Kerne gilt das auch schon, wenn die Threads einzeln einen Kern der CPU auslasten. Aber das ist ja auch logisch...