Dequeueing objets d'un ConcurrentQueue en C #

Hey, je suis en train de mettre en œuvre un ConcurrentQueue en C# pour un serveur asynchrones. Les éléments sont mis en file d'attente dès qu'un message est reçu. À la file d'attente de messages, je fais un petit nombre de threads pour faire le travail de dequeueing et traite les requêtes. C'est insuffisante comme chaque thread est à l'aide d'une boucle while, qui consomme plutôt une grande quantité de temps processeur, pour des raisons évidentes.

Serait ce que quelqu'un sait d'une méthode de dequeueing messages lorsque requis, mais ne consomme pas autant de temps de traitement.

{
    ...

    for (int i = 0; i < 3; i++)
    {
        Thread t = new Thread(new ThreadStart(startParsingMessages));
        t.Start();
    }

    ...
}

private void startParsingMessages()
{
    QueueContainer dequeued = null;
    Console.WriteLine("Trying");
    while (true)
    {
        if (queue.TryDequeue(out dequeued))
        {
            Console.WriteLine("processing queue");
            ProcessMessage(dequeued.socket, dequeued.message);
        }
    }
}

source d'informationauteur user352891

  1. 20

    Au lieu d'utiliser ConcurrentQueue<T> directement, avez-vous essayé en l'enveloppant dans un BlockingCollection<T>? Ensuite, vous pouvez utiliser TryTake(out T, TimeSpan) etc. Je crois que c'est l'usage attendu: que la concurrente des collections elles-mêmes généralement être là, de sorte que vous pouvez sélectionner la façon dont le blocage de la collection de travail.

    Qui n'a pas à être le seulement l'utilisation de ces collections, bien sûr, mais surtout pour ConcurrentQueue<T>le producteur/consommateur de la file d'attente est le scénario le plus commun - à quel point BlockingCollection<T> est la façon de faire, il est facile de faire la bonne chose.

  2. 5

    Il est assez bien connaître le motif dans la programmation simultanée Parallèle Producteur/Consommateur motif. Cet article peut aider à résoudre certains de vos problèmes. http://blogs.msdn.com/b/csharpfaq/archive/2010/08/12/blocking-collection-and-the-producer-consumer-problem.aspx

  3. 4

    Vous pouvez utiliser un blocage statique de l'objet pour les fils à attendre et ensuite impulsion quand quelque chose est prêt à être traité.

    static readonly object queueLock = new object();

//Threads that enqueue an object
void QueueMessage() {
  lock (queueLock) {
    queue.Enqueue(obj);
    Monitor.Pulse(queueLock);
  }
}
//Thread dequeuer
private void startParsingMessages() {
  QueueContainer dequeued = null;
  Console.WriteLine("Trying");
  while (true) {
    lock(queueLock) {
      if (!queue.TryDequeue(out dequeued)) {
        Console.WriteLine("No object to dequeue, waiting...");
        //Threads will wait here and only one will be released when .Pulse()d
        Monitor.Wait(queueLock);
        dequeued = queue.Dequeue();
      }
      if (dequeued != null) {
        Console.WriteLine("processing queue");
        ProcessMessage(dequeued.socket, dequeued.message);
      }
    }
  }
}

    Gardez à l'esprit que cela peut être assez compliqué avec les branches plus que vous avez, mais l'essentiel, c'est, vous le verrou sur un objet commun et appel Monitor.Wait attendre sur un objet pour être Pulsed. Lorsque cela arrive, un seul thread qui attendait qu'il sera libéré. Si vous mettre en file d'attente beaucoup d'objets et que vous voulez tous aller, vous pouvez appeler Monitor.PulseAll qui permettra de libérer tous les threads qui ont été en attente sur l'objet.