Hallo miteinander,

ich habe da eine Frage zum Threading.

Also ich habe eine Liste mit 100 Elemeten und will die Abarbeitung starten.



So werden nun alle Elemente gleichzeitig abgearbeitet. Wie schaffe ich es das nur eine bestimmte Anzahl an Elementen, zb 10, also eine Begrenzung, auf einmal abgearbeitet werden und das wenn hier nun ein Thread fertig ist der nächste Thread abgearbeitet wird und immer so weiter bis alle Elemente abgearbeitet wurden.

Ich hoffe es ist klar was ich meine, ich weiß nämlich ehrlich gesagt nicht wie ich das besser formulieren soll

Hoffe ihr könnt mir helfen!

Grüße
prophet

Verwende den Threadpool und ein Semaphor:

msdn.microsoft.com/de-de/library/dd781401.aspx
msdn.microsoft.com/de-de/libra…xdegreeofparallelism.aspx

versteh ich das mit dem semaphor richtig:

Also die erste Zahl sagt wie viel gleichzeitig abgearbeitet werden sollen und die 2te wieviel?

Also zb.:


Bearbeitet er dann 20 Threads gleichzeitig bis 100 erreicht wurden? Oder versteh ich da was falsch?!??

Ja ich habe die microsoft artikel bereits durchgelesen

prophet schrieb:

Ja ich habe die microsoft artikel bereits durchgelesen

Und warum verwendest du dann nicht Multitasking für Blöde, aka "Parallel.For" ?

Weils mit dem Semaphor funkioniert und ich nur noch mal für das richtige Verständnis nachfragen wollte!

prophet schrieb:

und ich nur noch mal für das richtige Verständnis nachfragen wollte!

ok

Bearbeitet er dann 20 Threads gleichzeitig bis 100 erreicht wurden? Oder versteh ich da was falsch?!??

Nein, nicht verstanden ...

Startwert, Maxwert.
Wert = 0 -> Geblockt

BTW: ICH würde ja parallel.for verwenden. Oder halt SemaphoreSlim, weil die "billiger" ist. Und man sollte GANZ genau überlegen, bevor man die Threadanzahl überhaupt vorgibt. Was wenn das Programm in drei Jahren auf ner 100-Kern CPU läuft? Der große Vorteil des JIT-Compiler ist ja, dass er sich bestmöglich dem AKTUELLEN Rechner (und ggf der aktuellen Auslastung) anpasst. Man sollte ihm also nur dann ins Handwerk pfuschen, wenn man gute Gründe hat.

Nochmal genauer: Der erste Parameter gibt die Anzahl Anfragen an, die das Semaphor anfangs gewähren kann. Der zweite Parameter ist die Anzahl Anfragen, die das Semaphor insgesamt gewähren kann. Wenn du also ein Objekt mit (10, 15) erstellst, dann bedeutet das soviel wie ein Objekt mit (15, 15), auf das schon 5 mal WaitOne aufgerufen wurde. Bei dieser Art Implementierung musst du aufpassen, dass du nicht zu oft Release() aufrufst, sonst kassierst du eine SemaphoreFullException. Wenn das passiert, hast du in deinem Code Mist gebaut und musst ihn überarbeiten. Diese Art von Exception sollte auf keinen Fall ignoriert werden.

Übrigens: Wie picoflop schon dauernd anmerkt, musst du bei manueller Synchronisation tatsächlich genau wissen, was du tust. Du hast damit die volle Kontrolle über die Threadverwaltung und damit nicht nur Macht, sondern auch Verantwortung. Das Async-Framework ist schon ne tolle Sache, weil es Parallelität quasi ohne Synchronisierung bietet. Das ist für die meisten Leute ausreichend. Was nun die sauberere / bessere Lösung ist ist wohl wieder einer der Religionskriege beim Programmieren.