Asynchrone Ausführung: Untersuchung der zeitweiligen Verzögerung zwischen zwei Protokollanweisungen ⇐ C#

[Guest]

Anwendung:
Wir verfügen über eine Multithread-Bibliothek, die mit NetStandard2.0 unter Verwendung der Programmiersprache C# erstellt wurde.
Bereitstellung:
Windows Server
Problembeschreibung:
Bei der Ausführung des folgenden Codeblocks in meiner Bibliothek tritt ein zeitweiliges Blockierungsproblem auf . Unter normalen Bedingungen wird die Ausführung innerhalb derselben Millisekunden abgeschlossen, manchmal gibt es jedoch eine Verzögerung von 5 bis 10 Sekunden zwischen zwei Protokollanweisungen. Ich möchte verstehen, was diese Verzögerung verursachen könnte.
Der problematische Codeblock befindet sich in der using-Anweisung in der folgenden Funktion:

Code: Select all

public class ToolCheckLayer
{
private async Task CheckAsync(CancellationToken cancellationToken)
{
Logger?.Info("KeepAlive is working...");
using (var messageListener = await _bus.CreateListenerAsync(cancellationToken).ConfigureAwait(false))
{
// Some operations
return true;
}
return false;
}
}

Protokollbeispiele:
Perfektes Szenario (keine Verzögerung):

Code: Select all

2025-01-21 13:33:37.7836|INFO|ToolCheckLayer[1]: KeepAlive is working...
2025-01-21 13:33:37.7836|DEBUG|Layer [1]: Creating listener...

Das schlimmste Szenario (Verzögerung):

Code: Select all

2025-01-21 13:33:37.7836|INFO|ToolCheckLayer[1]: KeepAlive is working...
--- Here: 5-10 seconds blocking sometimes less... ----------->
2025-01-21 13:33:47.7500|DEBUG|MessageBus[1]: Creating listener...

Code-Snippet:
Hier ist der relevante Code für die Erstellung des Bus-Listeners:

Code: Select all

public class MessageBus
{
private readonly ILogger _logger;
private readonly SemaphoreSlim _listenerSemaphore;
private readonly SemaphoreSlim _listenerSetSemaphore = new SemaphoreSlim(1);

public class MessageBusListener : IDisposable
{
private readonly ILogger _logger;
private readonly bool _privileged;
private readonly BufferBlock _queue;

public MessageBusListener(ILogger logger, bool privileged, Action disposeAction)
{
_logger = logger;
_priviledged = privileged;
_queue = new BufferBlock();
}

// Some Functions...
}

public MessageBus(ILogger logger, int maxConcurrentListeners)
{
_logger = logger;
_listenerSemaphore = new SemaphoreSlim(maxConcurrentListeners);
}

public async Task CreateListenerAsync(CancellationToken cancellationToken)
{
_logger?.Debug("Creating listener...");
await _listenerSemaphore.WaitAsync(cancellationToken);

var listener = new MessageBusListener(_logger, privileged: false, () =>
{
_listenerSemaphore.Release();
});

try
{
await _listenerSetSemaphore.WaitAsync();
// Operations
}
finally
{
_listenerSetSemaphore.Release();
}

return listener;
}
}

Bisherige Untersuchungen:
Das Problem tritt nicht regelmäßig auf; Dies geschieht zufällig nach Wochen oder Monaten reibungslosen Betriebs.
Während des Blockierungszeitraums wurden keine CPU-, Speicher- oder E/A-Engpässe beobachtet.
Fragen:< /strong>

• Was könnte diese zeitweilige Blockierung bei der Ausführung von CreateBusListenerAsync verursachen?
• Könnte da ein Potenzial bestehen? Probleme mit der Verwendung oder Implementierung von SemaphoreSlim Kontext?
• Sollte ich mir über die Verwendung von BufferBlock in MessageBusListener Sorgen machen?
  Gibt es empfohlene Ansätze, um dieses Problem weiter zu debuggen oder zu entschärfen?< /li>

Vielen Dank an alle, die im Voraus beigetragen haben.