Der effizienteste Weg, um eine Warteschlange zu überwachen

Question

Was ist der effizienteste Weg, um eine Warteschlange zu überwachen.

Das follwoing Stück Code das größte Schwein von Ressourcen:

/// <summary> 
/// Starts the service. 
/// </summary> 
private void StartService() 
{ 
    while (true) 
    { 
     //the check on count is not thread safe 
     while (_MessageQueue.Count > 0) 
     { 
      Common.IMessage message; 
      // the call to GetMessageFromQueue is thread safe 
      if (_MessageQueue.GetMessageFromQueue(out message) == true) 
      { 
       if (message.RoutingInfo == Devices.Common.MessageRoutingInfo.ToDevice) 
       { 
        _Port.SerialPort.WriteLine(message.Message); 
       } 
       if (message.RoutingInfo == Devices.Common.MessageRoutingInfo.FromDevice) 
       { 
        OnDeviceMessageReceived(new Common.DeviceMessageArgs(message.Message)); 
       } 
      } 
     } 
    } 
} 

Start Service auf Hintergrund-Thread ausgeführt wird, wird der Anruf an _MessageQueue.Count nicht Thread-sicher, ich bin Verriegelung nicht Zählung in Message auf. Ich sperre jedoch die Implementierung von _MessageQueue.GetMessageFromQueue. Bin ich so effizient gegangen? Soll ich eher ein Ereignis auslösen, wenn die Warteschlange von einer Zählung von 0 auf eine größere als Null geht?

Answer 1

Sie sollten wahrscheinlich eine Art von Thread Schlaf in diese Methode einschließen, sonst wird es 100% CPU verwenden. Alternativ können Sie ein Wait-Handle erstellen und festlegen, wenn Sie der Warteschlange eine Nachricht hinzufügen.

Answer 2

Wenn ich nichts verpasst habe - Sie warten auf die Eigenschaft _messageQueue.Count. Ich würde versuchen, etwas zu tun, wie zu geschehen ist: http://msdn.microsoft.com/en-us/library/yy12yx1f.aspx

Answer 3

Statt aktiv eine Abfrage der Warteschlange können Sie MSMQ Nachricht verbrauchen direkt in WCF mit einer NetMsmqBinding

http://msdn.microsoft.com/en-us/library/ms789008.aspx

Hoffnung, das hilft.

Answer 4

Wird _MessageQueue nur von Ihrem Code verwendet? Dann könnte man es in einer Klasse wie folgt wickeln:

public class BlockingMessageQueue { 
    private readonly MyMessageQueue queue; 
    private readonly Semaphore signal; 

    public BlockingMessageQueue(MyMessageQueue queue) { 
    this.queue = queue; 
    this.signal = new Semaphore(0, int.MaxValue); 
    } 

    public void Enqueue(IMessage message) { 
    lock (this.queue) { 
     this.queue.Send(message); 
    } 
    this.signal.Release(); 
    } 

    public IMessage Dequeue() { 
    this.signal.WaitOne(); 
    IMessage message; 
    lock (this.queue) { 
     var success = this.queue.GetMessageFromQueue(out message); 
     Debug.Assert(success); 
    } 
    return message; 
    } 
} 

Dequeue blockiert, bis eine Nachricht verfügbar ist, so gibt es keine verschwendeten Zyklen, wenn keine Nachricht verfügbar ist.

Anwendungsbeispiel:

var queue = new BlockingMessageQueue(_MessageQueue); 

while (true) { 
    var message = queue.Dequeue(); 

    if (message.RoutingInfo == Devices.Common.MessageRoutingInfo.ToDevice) 
    { 
    _Port.SerialPort.WriteLine(message.Message); 
    } 
    else if (message.RoutingInfo == Devices.Common.MessageRoutingInfo.FromDevice) 
    { 
    OnDeviceMessageReceived(new Common.DeviceMessageArgs(message.Message)); 
    } 
}