System.Threading.SemaphoreFullException: Adding the specified count to the semaphore would cause it to exceed its maximum count.
Ai apelat `Release()` pe un `SemaphoreSlim` de mai multe ori decât `Wait` / `WaitAsync`, de obicei de două ori în același bloc (o dată în `try`, o dată în `finally`) sau fără să fi intrat. Fiecare `Release()` trebuie să corespundă unui `Wait` reușit: pune-l o singură dată, în `finally`, după un `await WaitAsync()` reușit.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Un SemaphoreSlim(initial, maxim) limitează câte bucăți de cod pot rula în același timp: WaitAsync() ocupă un loc, Release() îl eliberează. Dacă eliberezi mai multe locuri decât maximul permis, semaforul ar ajunge să aibă mai multe locuri libere decât capacitatea, iar .NET aruncă System.Threading.SemaphoreFullException: Adding the specified count to the semaphore would cause it to exceed its maximum count..
Excepția indică aproape mereu un dezechilibru între Wait și Release:
Release()apare și întry, și înfinally;WaitAsync(timeout)a întorsfalse(nu s-a intrat), darfinallyface totușiRelease();WaitAsync()e chemat în interiorultry, iar o excepție sau o anulare apare înainte să se intre, darfinallyeliberează.
Modelul corect: await sem.WaitAsync(); înainte de try, apoi try { ... } finally { sem.Release(); }. Cu timeout: if (!await sem.WaitAsync(t)) return; înainte de try. Fără maxim explicit (new SemaphoreSlim(1)), excepția nu apare, dar dezechilibrul tot e o greșeală: permite mai multe intrări simultane decât ai vrut.
De ce apare: cauzele frecvente
1Release dublu, în try și în finally
await sem.WaitAsync();
try
{
Proceseaza();
sem.Release();
}
finally { sem.Release(); }await sem.WaitAsync();
try
{
Proceseaza();
}
finally { sem.Release(); }Un singur Release(), în finally, pentru un singur WaitAsync().
2Release chiar dacă nu s-a intrat
try
{
if (!await sem.WaitAsync(100)) return;
Proceseaza();
}
finally { sem.Release(); }if (!await sem.WaitAsync(100)) return;
try
{
Proceseaza();
}
finally { sem.Release(); }Blocul try începe abia după ce intrarea a reușit.
3WaitAsync în interiorul try
try
{
await sem.WaitAsync(token);
await LucreazaAsync();
}
finally { sem.Release(); }await sem.WaitAsync(token);
try
{
await LucreazaAsync();
}
finally { sem.Release(); }Dacă WaitAsync e anulat, nu s-a intrat, deci nu trebuie eliberat nimic.
Repară eroarea, direct în pagină
Programul procesează fișiere pe rând, protejat de un SemaphoreSlim(1, 1), dar se oprește cu System.Threading.SemaphoreFullException: Adding the specified count to the semaphore would cause it to exceed its maximum count. Repară metoda ca programul să afișeze Procesez a.csv, Procesez b.csv și Gata: 2 fisiere.
var sem = new SemaphoreSlim(1, 1);
int procesate = 0;
foreach (var f in new[] { "a.csv", "b.csv" })
await Proceseaza(f);
Console.WriteLine($"Gata: {procesate} fisiere");
async Task Proceseaza(string fisier)
{
await sem.WaitAsync();
try
{
await Task.Delay(10);
Console.WriteLine($"Procesez {fisier}");
procesate++;
sem.Release();
}
finally
{
sem.Release();
}
}Procesez a.csv Procesez b.csv Gata: 2 fisiere
Indiciu
Fiecărui WaitAsync() reușit îi corespunde exact un Release().
Reparația
var sem = new SemaphoreSlim(1, 1);
int procesate = 0;
foreach (var f in new[] { "a.csv", "b.csv" })
await Proceseaza(f);
Console.WriteLine($"Gata: {procesate} fisiere");
async Task Proceseaza(string fisier)
{
await sem.WaitAsync();
try
{
await Task.Delay(10);
Console.WriteLine($"Procesez {fisier}");
procesate++;
}
finally
{
sem.Release();
}
}De ce merge
Metoda elibera semaforul de două ori pentru o singură intrare: o dată în try și o dată în finally. Cu capacitatea maximă 1, al doilea Release() arunca excepția. Cu un singur Release() în finally, semaforul revine la un loc liber după fiecare fișier, iar al doilea fișier poate intra.
Cum o eviți pe viitor
- Folosește mereu modelul:
await sem.WaitAsync();urmat detry { ... } finally { sem.Release(); }. - Dă un maxim explicit (
new SemaphoreSlim(3, 3)): unReleaseîn plus devine imediat excepție, nu o greșeală ascunsă. - Pentru excludere simplă poți folosi
lock(cod sincron) sau o clasă ajutătoare care faceReleaseînDispose.
Întrebări frecvente
Ce înseamnă cele două numere din constructor?
Primul e câte locuri sunt libere la început, al doilea e capacitatea maximă. new SemaphoreSlim(1, 1) e un „lacăt” pentru cod asincron: o singură intrare odată.
Pot folosi lock în loc de SemaphoreSlim?
Nu în cod cu await: nu poți face await într-un bloc lock (eroarea CS1996). SemaphoreSlim cu WaitAsync e varianta pentru cod asincron.
Erori înrudite
error CS1996: Cannot await in the body of a lock statement Ai scris `await` în interiorul unui bloc `lock`. Un `lock` trebuie eliberat de același fir care l-a luat, iar după `await` codul poate continua pe alt fir. Înlocuiește `lock` cu `SemaphoreSlim(1, 1)`: `await sem.WaitAsync(); try { ... } finally { sem.Release(); }`. System.ObjectDisposedException: Cannot access a disposed object. Ai folosit un obiect după ce a fost eliberat cu `Dispose()` sau la ieșirea dintr-un bloc `using` (un stream, un `StreamWriter`, un `HttpClient`, un `CancellationTokenSource`). Mută tot codul care folosește obiectul în interiorul blocului `using` sau creează un obiect nou. System.InvalidOperationException: An attempt was made to transition a task to a final state when it had already completed. Ai apelat `SetResult`, `SetException` sau `SetCanceled` de două ori pe același `TaskCompletionSource`. Un task se poate termina o singură dată. Folosește `TrySetResult` (care întoarce `false` dacă task-ul era deja terminat) sau creează un `TaskCompletionSource` nou pentru fiecare operație. Învață C# de la zero, cu exerciții la fiecare lecție
Curs C#: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
