Concurrent collections Essen zu viel cpu ohne Gewinde.Schlafen

Was wäre die korrekte Verwendung von entweder BlockingCollection oder ConcurrentQueue so können Sie frei dequeue Elemente ohne Sie zu verbrennen, sich die Hälfte oder mehr der CPU einen thread ?

Ich lief einige tests mit 2 threads und es sei denn, ich hatte einen Thread.Schlaf von mindestens 50~100ms würde es treffen immer mindestens 50% meiner CPU.

Hier ist ein fiktives Beispiel:

private void _DequeueItem()
{
    object o = null;
    while(socket.Connected)
    {
        while (!listOfQueueItems.IsEmpty)
        {
            if (listOfQueueItems.TryDequeue(out o))
            {
                //use the data
            }
        }
    }
}

Mit dem obigen Beispiel würde ich ein thread.schlafen, damit die cpu nicht sprengen.

Hinweis: ich habe auch versucht es ohne, während für die IsEmpty-Prüfung, Ergebnis war das gleiche.

Wenn Sie nichts tun, außer dequeueing dann 50% CPU-Auslastung ziemlich normal ist, im Allgemeinen mit den Threads ist es noch wichtiger, schauen Sie sich die einzelnen Kerne um die Leistung zu beurteilen.
das klingt nicht richtig, abarbeiten der Warteschlange ist ein kleiner Betrieb. Das problem hier ist der thread sollte auf ein signal warten, um aufzuwachen, das signal sagen, es gibt etwas zu entfernen, anstatt mit einer unendlich engen Schleife zu versuchen, die Warteschlange entfernen. Das würde eine WINZIGE Menge der CPU, bei weitem nicht 50%
Sie haben Recht, ich verpasst - war gerade auf der Suche auf die schlechte Idee, um nicht ansehen Familienmitglied Kerne!

InformationsquelleAutor Prix | 2011-07-01

c#concurrent-collections multithreading

22

Ist es nicht, weil der BlockingCollection oder ConcurrentQueue, aber die while-Schleife:
```
while(socket.Connected)
{
    while (!listOfQueueItems.IsEmpty)
    { /*code*/ }
}
```
Natürlich wird die cpu nach unten; denn wenn die queue leer ist, dann wird die while-Schleife ist genau wie:
```
while (true) ;
```
die wiederum fressen die cpu-Ressourcen.

Dies ist nicht ein guter Weg, mit ConcurrentQueue Sie verwenden sollten AutoResetEvent mit jedem Element Hinzugefügt wird, werden Sie benachrichtigt.
Beispiel:
```
private ConcurrentQueue<Data> _queue = new ConcurrentQueue<Data>();
private AutoResetEvent _queueNotifier = new AutoResetEvent(false);

//at the producer:
_queue.Enqueue(new Data());
_queueNotifier.Set();

//at the consumer:
while (true)//or some condition
{
    _queueNotifier.WaitOne();//here we will block until receive signal notification.
    Data data;
    if (_queue.TryDequeue(out data))
    {
        //handle the data
    }
}
```
Für eine gute Nutzung der BlockingCollection sollten Sie die GetConsumingEnumerable() warten für die Elemente Hinzugefügt werden, Wie:
```
//declare the buffer
private BlockingCollection<Data> _buffer = new BlockingCollection<Data>(new ConcurrentQueue<Data>());

//at the producer method:
_messageBuffer.Add(new Data());

//at the consumer
foreach (Data data in _buffer.GetConsumingEnumerable())//it will block here automatically waiting from new items to be added and it will not take cpu down 
{
    //handle the data here.
}
```
- Aldeen Saa würde das event funktioniert wirklich gut, vielen Dank, was waitone nicht warten 1 ms ?
- Ich habe gerade feststellen, dass Ihre Frage heute: "was waitone nicht warten, ms ?", Nein, Der WaitOne ist eine Blockierung, bis es erhält ein signal. In den code: _queueNotifier.Set(); ist das signal "hier zeigt das neue Element wird Hinzugefügt" Lesen Sie mehr auf AutoResetEvent hier.
- Es wartet, bis das Ereignis eingestellt ist.
- Ich bin mir ziemlich sicher, dies ist aufgebläht und un-nötig (hören: auch Handbuch). Es ist ein Take Funktion in der BlockingCollection das dient genau diesem Zweck, ohne die Notwendigkeit für die manuelle signal/wait.
- das ist Weg ich habe geben Sie dem zweiten Beispiel der Verwendung von 'BlockingCollection', weil durch die Verwendung von 'GetConsumingEnumerable()' was ist dasselbe wie 'Nimm ()" - Funktion, dann ist kein muss alle Aufrufe von signal/wait, aber der erste Teil meiner Antwort ist zu verwalten die korrekte Verwendung von 'ConcurrentQueue' allein, ohne 'BlockingCollection' zu dem gleichen Zweck dienen, dann werden Sie brauchen, um irgendeine Art von Signal.
- Vielen Dank für die Präsentation Ihrer gute Lösung, Aber ich will immer laufen und Zuhören .Wenn _buffer.Zahl <= 0 Abhören zu stoppen und hinzufügen wird ein neuer Eintrag nicht mehr aufrufen, dieses Ereignis
InformationsquelleAutor Jalal Said
7

Sie wirklich wollen, um mit der BlockingCollection Klasse in diesem Fall. Es wurde entwickelt, um zu blockieren, bis ein Element in die Warteschlange. Eine Sammlung dieser Art wird oft als eine blockierende Warteschlange. Diese Art der Implementierung ist sicher für mehrere Produzenten und mehrere Verbraucher. Das ist etwas, das ist überraschend schwer zu bekommen Recht, wenn Sie versucht, es umzusetzen sich. Hier ist, was Ihr code Aussehen würde, wenn Sie verwendet werden BlockingCollection.
```
private void _DequeueItem()
{
    while(socket.Connected)
    {
        object o = listOfQueueItems.Take();
        //use the data
    }
}
```
Den Take Methode blockiert automatisch, wenn die Warteschlange leer ist. Es blockiert in einer Weise, legt den Faden in der SleepWaitJoin Zustand, so dass es nicht verbrauchen CPU-Ressourcen. Die nette Sache über BlockingCollection ist, dass es verwendet auch low-lock-Strategien zur Steigerung der performance. Was dies bedeutet ist, dass Take wird überprüfen, um zu sehen, ob es ein Element in die Warteschlange und wenn nicht dann wird es kurz führen Sie eine Drehung warten, um zu verhindern, dass ein Kontext-wechseln der thread. Wenn die Warteschlange noch leer ist, dann wird der thread schlafen. Dies bedeutet, dass BlockingCollection haben einige der performance-Vorteile ConcurrentQueue bietet in Hinblick auf die gleichzeitige Ausführung.
- BlockingCollection verwendet ConcurrentQueue standardmäßig, es sei denn, ein IProducerConsumerCollection an den Konstruktor übergeben wird der BlockingCollection. also, per definition sollte es haben, alle Vorteile, ConcurrentQueue (es sei denn, eine andere Sammlung verwendet wird).
InformationsquelleAutor Brian Gideon

Können Sie anrufen Thread.Sleep() nur, wenn die Warteschlange leer ist:

private void DequeueItem()
{
    object o = null;

    while(socket.Connected)
    {
        if (listOfQueueItems.IsEmpty)
        {
            Thread.Sleep(50);
        }
        else if (listOfQueueItems.TryDequeue(out o))
        {
            //use the data
        }
    }
}