Het gebruik van de SemaphoreSlim class in C#

Webapplicaties kunnen meerdere calls vanuit meerdere plekken verwerken zonder dat deze requests op elkaar moeten wachten. Maar soms heb je te maken met een usecase waar je helemaal niet wilt dat functionaliteit meerdere calls kan verwerken tegelijkertijd. Denk hier bijvoorbeeld aan functionaliteit die grote bedragen verwerkt of een functie die veel resources kost. Hier kun je gebruik maken van de SemaphoreSlim class welke je in staat stelt om controle uit te voeren op wie er wanneer toegang heeft tot bepaalde resources.

Het kan soms voorkomen dat binnen je applicatie een bepaalde functie vrij veel resources kost om te kunnen draaien, bijv. qua geheugengebruik of qua CPU gebruik. Of je kunt te maken hebben met een functionaliteit die met bijv. geldstromen werkt waarbij je niet wilt dat daar requests mogelijk dubbel verstuurd worden of dat daar teveel requests tegelijk verstuurd worden. Het kan in deze gevallen handig zijn om de toegang tot deze functionaliteiten te beperken om te zorgen dat alles goed blijft werken. De toegang tot een functionaliteit beperken kan op verschillende manieren aangepakt worden. Je kunt gebruik maken van een static variabele die je in de controller zet. Deze variabele zet je zodra de functie bezig is en reset je als de functie klaar is. Het nadeel hieraan is dat requests die gedaan worden terwijl de code bezig is op deze manier verloren gaan. Als iemand de functie toch wilt aanroepen dan moet het request nogmaals gedaan worden, deze worden niet bewaard en alsnog uitgevoerd als de functie klaaris. Wat wel aan deze eisen voldoet, is het gebruik van de SemaphoreSlim class.

Om de toegang tot de functionaliteit te beheren, kan je gebruik maken van de SemaphoreSlim class. Met deze class kun je het aantal threads beperken dat tegelijkertijd toegang heeft tot bepaalde resources. In andere woorden, deze class wacht tot de functie is uitgevoerd totdat het toegang verleent naar de functie aan de volgende thread. SemaphoreSlim is een lichtere versie van de Semaphore class. Je kunt daarnaast opgeven hoeveel threads er tegelijkertijd toegang hebben tot een functie. Wordt dit aantal overschreven, dan worden deze threads ‘in de wacht gezet’ totdat de vorige thread klaar is.

Een voorbeeld van het gebruik van de SemaphoreSlim class:

Bij het initialiseren van de class geef je aan hoeveel threads gelijktijdig gebruik mogen maken van de functie die de SemaphoreSlim class afschermt. In bovenstaand voorbeeld is dat dus 1 thread. Daarna vertel je de code met Wait() dat als het maximum aantal theads is bereikt, de code hier wacht totdat de functie klaar is en er weer toegang is tot de class. Met Release() geef je weer een plek vrij en kan de volgende thread gebruik maken van de functie. Als je dit in een finally zet dan weet je zeker de er een plek vrijgegeven wordt, zelfs als een fout optreedt en de code hier dus nooit vast staat.

Dit was een introducatie tot de SemaphoreSlim class, mocht je meer willen lezen dan kan dat hier:

https://docs.microsoft.com/en-us/dotnet/standard/threading/semaphore-and-semaphoreslim