TList mit Record füllen und an weitere TList übergeben

**Aviator**

Zitat von p80286:

Zitat von Mavarik:

Zitat von dGeek:

Kann es sein, dass MeineObjectList.Clear; direkt auch Free igendwo aufruft?

Klar... Das ist ja genau der Trick!

Bittää?
Das wäre doch ein sehr überraschender Effekt. Wenn ein .Delete() oder ein .Clear ein .Free des ListenItems nach sich zieht ok, aber ein .Free auf die Liste??

Tut es ja nicht. Ich würde behaupten er hat sich nur falsch ausgedrückt oder zu schnell geschrieben. Die Liste selbst bleibt durch ein Clear selbstverständlich erhalten. Nur die Items darin werden (sofern OwnsObjects auf True) freigegeben. OwnsObjects kann mein Create oder aber auch nachträglich als Eigenschaft der Liste auf False bzw. True gesetzt werden.

Scheinbar mag mich die Object-List nicht.

Kurze erklärung:
ich habe eine Liste von Dateien.
Die speichere ich mit noch ein paar anderen Informationen in diese "Instanzen" von TFileEntry ab.
Alle Instanzen kommen dann in ObjectList-A.

Nun gehe ich diese ObjectList-A durch und teile sie in n-Stückchen auf. Mit diesen Stücken werden Threads gefüttert und gestartet.
Bei 100 Instanzen erhält bei 5 Threads jeder Threads also 20 Instanzen, die er abarbeiten soll.

Mein einfacher Test:
es gibt 10 Instanzen und 2 Threads. 5 Pro Thread.

jetzt das Seltsame: beide Threads bekommen dieselbe Instanz!

Meine Logik ist also:
- Dateiliste erstellen
- Für jede Datei 1 Instanz von TFileEntry erstellen
- alle Instanzen in die ObjectList-A

Nun ObjectList-A.Count durch die Anzahl der Threads teilen. Ergibt 5 Instanzen pro Thread / 2 Threads.
Diese 5 Instanzen werden in eine temporäre ObjectList-B geschrieben, die kurz vorher außerhalb der for-schleife erzeugt wird.
Am ende der for-Schleife übergebe ich ObjectList-B an eine Procedur wo nichts weiter drin steht als, dass ein TThread erzeugt werden soll. Er hat ein Property und das ist eine ObjectList.

**Aviator**

Zitat von dGeek:

Scheinbar mag mich die Object-List nicht.

Kurze erklärung:
ich habe eine Liste von Dateien.
Die speichere ich mit noch ein paar anderen Informationen in diese "Instanzen" von TFileEntry ab.
Alle Instanzen kommen dann in ObjectList-A.

Nun gehe ich diese ObjectList-A durch und teile sie in n-Stückchen auf. Mit diesen Stücken werden Threads gefüttert und gestartet.
Bei 100 Instanzen erhält bei 5 Threads jeder Threads also 20 Instanzen, die er abarbeiten soll.

Mein einfacher Test:
es gibt 10 Instanzen und 2 Threads. 5 Pro Thread.

jetzt das Seltsame: beide Threads bekommen dieselbe Instanz!

Meine Logik ist also:
- Dateiliste erstellen
- Für jede Datei 1 Instanz von TFileEntry erstellen
- alle Instanzen in die ObjectList-A

Nun ObjectList-A.Count durch die Anzahl der Threads teilen. Ergibt 5 Instanzen pro Thread / 2 Threads.
Diese 5 Instanzen werden in eine temporäre ObjectList-B geschrieben, die kurz vorher außerhalb der for-schleife erzeugt wird.
Am ende der for-Schleife übergebe ich ObjectList-B an eine Procedur wo nichts weiter drin steht als, dass ein TThread erzeugt werden soll. Er hat ein Property und das ist eine ObjectList.

Zeig mal etwas SourceCode. Dann wird es vmtl. einfacher dir zu helfen.

Ich könnte mir vorstellen wo dein Fehler ist, aber ich will nicht wild drauf losraten.

Ihr werdet mich für den Code HASSEN

(poste ich gleich aber erst eine Frage).

Ich habe mittlerweile herausgefunden, dass wenn ich nach der Procedur die den Thread erstellt eine Showmessage mache, alles korrekt abläuft. Scheint also ein sehr suspektes Zeitproblem zu sein.

geht deine Vermutung in diese Richtung?

**Aviator**

Zitat von dGeek:

geht deine Vermutung in diese Richtung?

Nein eher nicht.

Es kann natürlich sein, das ich mit meiner Vermutung total falsch liege.

Zitat von dGeek:

Ihr werdet mich für den Code HASSEN

Jeder hat doch mal klein angefangen. Als ich das erste Mal mit ObjectLists gearbeitet hatte, ging auch nicht alles direkt. Heute will ich sie nicht mehr missen. Da hakte es auch an der ein oder anderen Stelle. Und die Formatierung des SourceCodes kannst du ja schnell durch die IDE machen lassen falls du das meinst.

Ich habe alles Unwichtige rausgenommen und ein bisschen Pseudo-Kommentiert, damit man es HALBWEGS nachvollziehen kann

Threads sind nicht das Problem. Denn als ich das alles ohne ObjectList hatte, lief es einwandfrei.

zusammenfalten · markieren

Delphi-Quellcode:

			// aProcessFileList_ObjectList enthält "10" Instanzen von TFileEntry

// aProcessFileList_ObjectList.OwnsObjects ist "False"

// aGlobalVars.iMaxCopyThreadCount ist "2"

// iFilesPerThread ist "5"

// Der ganze StringList-Kram ist nur zum TEST da

{*

 Dateien z.B.:

 - Datei0.txt

 - Datei1.txt

 - Datei2.txt

 - Datei3.txt

 - Datei4.txt

 - Datei5.txt

 - Datei6.txt

 - Datei7.txt

 - Datei8.txt

 - Datei9.txt

*}

aTmpFileList_ObjectList := TObjectList.Create;

aTmpFileList_ObjectList.OwnsObjects := False;

try

 for i := 0 to aGlobalVars.iMaxCopyThreadCount - 1 do

  begin

   Application.ProcessMessages;

   try

    if aProcessFileList_ObjectList.Count >= iFilesPerThread then

     begin

      // Liste wird geleert, damit nicht die alten Daten drin sind / SEIN SOLLTEN

      aTmpFileList_ObjectList.Clear;

      iCnt := iFilesPerThread;

      if aProcessFileList_ObjectList.Count - iCnt = 1 then

       Inc(iCnt);

      {*

        Erster  Durchgang: aTmpFileList_ObjectList bekommt "Datei0" bis "Datei4"

        Zweiter Durchgang: aTmpFileList_ObjectList bekommt "Datei5" bis "Datei9"

      *}

      for j := 0 to iCnt - 1 do

       aTmpFileList_ObjectList.Insert(j, aProcessFileList_ObjectList.Items[j]);

      sl := TStringList.Create;

      try

       {*

         Erster  Durchgang: aus aProcessFileList_ObjectList wird "Datei4" bis "Datei0" gelöscht

         Zweiter Durchgang: aus aProcessFileList_ObjectList wird "Datei9" bis "Datei5" gelöscht

       *}

       for j := iCnt - 1 downto 0 do

        begin

         aProcessFileList_ObjectList.Delete(j);

         sl.Add(TFileEntry(aTmpFileList_ObjectList.Items[j]).sSourceDirItem);

        end;

       // StringList-TEST - was ist in der Liste? In eine Datei abspeichern!

       sl.SaveToFile(ExtractFilePath(ParamStr(0)) + '__DELETE' + IntToStr(i) + '.txt');

      finally

       sl.Free;

      end;

      sl := TStringList.Create;

      try

       for j := 0 to aTmpFileList_ObjectList.Count - 1 do

        begin

         sl.Add(TFileEntry(aTmpFileList_ObjectList.Items[j]).sSourceDirItem);

        end;

       // StringList-TEST - was ist in der Liste? In eine Datei abspeichern!

       sl.SaveToFile(ExtractFilePath(ParamStr(0)) + '__' + IntToStr(i) + '.txt');

      finally

       sl.Free;

      end;

      if aTmpFileList_ObjectList.Count > 0 then

       begin

        {*

          Erster  Durchgang: Thread1 arbeitet "Datei0" bis "Datei4" ab

          Zweiter Durchgang: Thread2 arbeitet "Datei5" bis "Datei9" ab

        *}

        createCopyThread(aTmpFileList_ObjectList);

       end;

     end

    else

     break;

   except

    // ...

   end;

  end;

  // Wenn noch RESTE in der originalen ObjectList sind, dann erstelle damit einen seperaten Thread

  // Das ist z.B. der Fall, wenn 11 Dateien verarbeitet werden müssten. Die letzte (elfte) Datei würde hier in einen Thread gepackt werden

  if aProcessFileList_ObjectList.Count > 0 then

   begin

    createCopyThread(aProcessFileList_ObjectList);

   end;

  end;

finally

 aTmpFileList_ObjectList.Free;

end;

////////////////////////////////////////////////////////////////////////////////

procedure createCopyThread(FaFileList: TObjectList);

 var

  aCopyThread: TCopyThread;

 begin

  aCopyThread := TCopyThread.Create;

  aCopyThread.aFileList := FaFileList;

 end;

////////////////////////////////////////////////////////////////////////////////

type

 TCopyThread = class(TThread)

 private

  { Private-Deklarationen }

  FaFileList: TObjectList;

 protected

  procedure Execute; override;

 public

  { Public-Deklarationen }

  constructor Create;

  procedure Finish(Sender: TObject);

  property aFileList: TObjectList read FaFileList write FaFileList;

 end;

**DeddyH**

Zitat von dGeek:

Threads sind nicht das Problem.

Bist Du da ganz sicher? Du musst bedenken, dass der Code, der nach dem Erzeugen der Threads kommt, auch weiter ausgeführt wird, während die Threads noch laufen.

**stahli**

Dein Problem ist offenbar nicht mehr die TList sondern die Synchronisierung von Threads.

In dem Fall wäre das dann auch ein Thema für einen neuen "Thread".

Hier gab es kürzlich eine nette Zusammenfassung:

https://www.youtube.com/watch?v=Jhcpgjs1uPA

**Mavarik**

Zitat von dGeek:

Ihr werdet mich für den Code HASSEN

Hassen - nein - nur viel zu umständlich - aber da Du in Deinem Profil nicht angegeben hast, welche Delphi Version Du nutzt, gehe ich davon aus, diese ist kleine XE6, oder?

Das Geld reicht nur für XE2.
Umständlich ist mein zweiter Vorname.

Ich habe erst letztens noch eine Funktion komplett neugeschrieben. Sie wurde insgesamt sehr viel schneller.
Bei 1.000.000 Aufrufen spare ich 200ms.

Ich brauche diese Funktion exakt ein einziges mal in meinem Code. Hat sich demnach also gelohnt