TThreadList

Das ist keine Liste von Threads (TObjectList ist ja eine Liste von Objekten),
sondern es ist eine TList mit eingebauter Threadabsicherung. (also eigentlich eine TThreadsaveList)



Wieso Manuell aufteilen?
Lass die Einträge sich doch einfach dynamisch vereilen. (wer Zeit hat, der macht es)

* alle Aufgaben/Dateien in eine TThreadList
* dann X Threads starten (so viele, wie gewünscht)
* jeder Thread holt sich via ThreadList.Pop einwas raus
* * verarbeitet das
* * und wiederholt dann seine Schleife so oft, bis nichts mehr in der ThreadList drin ist
* dann kann er sich beenden (oder wartet, bis wieder was rein kommt, und arbeitet weiter)

Vorteile
* die ThreadList ist schon thread-sicher (hat die CriticalSection/Monitor bereits einbebaut)
* und wenn nicht alle Aufgaben gleich lange dauern, dann geht es auch schneller

Zitat von DieDolly:

In meinem Fall also?

markieren

Delphi-Quellcode:

TParallel.For(MainProcessFileList_ObjectList.Count div MaxThreadCount, 1, MainProcessFileList_ObjectList.Count,
 procedure(Index: Integer)
  begin
   // Bearbeite Listeneintrag[Index]
  end);

Das geht so, aber dann musst du Listeneintrag[Index - 1] bearbeiten, denn schließlich zählt die Schleife ja von 1 los. Deshalb solltest du die lieber bei 0 loslaufen lassen und bis Count - 1 laufen lassen wie es üblich ist. Ansonsten stimmt das, ja.

Zitat von DieDolly:

Das Execute ist egal und tut nichts zur Sache. Den Code davon ändere ich ohnehin nicht.

Wenn dort dann die Dateien von der Festplatte gelesen werden, wird die Aufteilung in Threads das ganze eben wie gesagt eher langsamer machen, es sei denn die Verarbeitung dauert deutlich länger als das Lesen von der Festplatte. Das ist aber oft gar nicht so.

Ich habe das TFor.Parallel noch immer nicht richtig verstanden.

Wenn ich 20 Dateien habe und 2 Threads daraus machen möchte, wie genau zählt Schleife 1 und wie Schleife 2?
Fängt Schleife 1 an zu zählen bei Index 0 an bis 9 und Schleife bei 10 von 19 ?
Weil ich brauche in irgendeiner Art und Weise eine Schleifenvariable die ich in jeder dieser For-Dinger nutzen kann. Ich muss wissen wann "0" ist.

Bei 0 erstelle ich eine temporäre ObjectList. Bei Index = MaxForFürDiesenDurchgang erzeuge ich den Thread.


Eine andere Idee. Jetzt gerade ist es so, dass Unit A die ObjectList in mehrere aufteilt und daraus Daten für Unit B (ein Thread) baut.
1000 Dateien, 8 Threads sollen gebaut werden, jeder Thread 125 Dateien.

Wenn ich das mit der neuen Herangehensweise mache, gäbe es nur noch EINEN Thread, der intern TParallel.For nutzt. Die Aufteilung und Verwaltung macht dann also TParallel.For.

Hat das irgendwelche Vorteile?

Zitat von DieDolly:

Ich habe das TFor.Parallel noch immer nicht richtig verstanden.

Wenn ich 20 Dateien habe und 2 Threads daraus machen möchte, wie genau zählt Schleife 1 und wie Schleife 2?
Fängt Schleife 1 an zu zählen bei Index 0 an bis 9 und Schleife bei 10 von 19 ?
Weil ich brauche in irgendeiner Art und Weise eine Schleifenvariable die ich in jeder dieser For-Dinger nutzen kann. Ich muss wissen wann "0" ist.

Bei 0 erstelle ich eine temporäre ObjectList. Bei Index = MaxForFürDiesenDurchgang erzeuge ich den Thread.

Lös dich doch mal von deinem Thread, der mehrere Einträge aus einer temporären Liste bearbeitet.
Das TParallel.For behandelt alle Listeneinträge von 0 bis Count - 1 (Danke Sebastian), wobei die Arbeit an einem Eintrag innerhalb der anonymen Methode erfolgt.

Stell dir das erstmal wie bei einer ganz normalen Schleife vor:

markieren

Delphi-Quellcode:

for I := 0 to MainProcessFileList_ObjectList.Count - 1 do
begin
  { Tue was mit MainProcessFileList_ObjectList[I] }
end;

Willst du das parallel mit 8 Threads erledigen, schreibst du das so:

markieren

Delphi-Quellcode:

MaxThreadCount := 8;
FilesPerThread := MainProcessFileList_ObjectList.Count div MaxThreadCount;
TParallel.For(FilesPerThread, 0, MainProcessFileList_ObjectList.Count - 1,
  procedure(Index: Integer)
  begin
    { Tue was mit MainProcessFileList_ObjectList[Index] }
  end);

Das { Tue was mit MainProcessFileList_ObjectList[I] } versteckt sich aktuell noch irgendwo in der Execute Methode deines Threads. Insofern ist das eben nicht egal. Vielleicht passiert innerhalb dieser Methode ja auch etwas, dass diesen Ansatz unmöglich macht oder eine Änderung dessen erfordert, aber das wissen wir nicht.

Zitat von DieDolly:

Ich habe eine TObjectList die eine Dateiliste repräsentiert.
Wie stellt man das am besten an? Ich meine nicht rechnerisch sondern das Erstellen der Threads, ohne temporäre Zwischenlisten.

TObjectList ist nicht threadsafe, daher Vorsicht walten lassen!

Du machst dir schon vorher Gedanken über die Lastverteilung.

Wenn du die Aufgaben (Dateien) in eine Blocking Collection packst,
dann können die Threads sich selbst bedienen, je nachdem ob einer mal schneller oder langsamer ist.
Du kannst auch Threads abhängig von der CPU erstellen (lassen) - also nicht gleich auf x festlegen.








___
von 0 auf 100 - Omni Thread Lib (OTL) - Multithreading einfach in Delphi
https://www.youtube.com/watch?v=OBBjqxxw31Y

Zitat von generic:

TObjectList ist nicht threadsafe, daher Vorsicht walten lassen!

Solange man sie nur einmal befüllt und die Threads nur lesend darauf zugreifen, sehe ich im Quelltext nichts, das dabei Probleme machen würde.

Zitat von jaenicke:

Solange man sie nur einmal befüllt und die Threads nur lesend darauf zugreifen, sehe ich im Quelltext nichts, das dabei Probleme machen würde.

Nur solange das Befüllen beendet ist sobald das Lesen los geht. Beim Add könnte das implementierende Array der Liste neu zugewiesen werden. Das ohne Synchronisation durchzuführen wäre mir zu heikel. Selbst wenn das aktuell safe ist, könnte sich die Implementierung in Zukunft ja ändern.

Zitat:

Solange man sie nur einmal befüllt und die Threads nur lesend darauf zugreifen, sehe ich im Quelltext nichts, das dabei Probleme machen würde.

Zitat:

Nur solange das Befüllen beendet

Ich befülle die ObjectList aus dem Main-Thread heraus.
Erst dann erzeuge ich einen Thread, der mit der ObjectList (lesend) arbeitet.

Zitat von DieDolly:

Ich befülle die ObjectList aus dem Main-Thread heraus.
Erst dann erzeuge ich einen Thread, der mit der ObjectList (lesend) arbeitet.