Kontener z limitem jednego CPU może zamienić pętlę Parallel.ForEachAsync w .NET z równoległej na szeregową — i to bez żadnego błędu, wyjątku czy ostrzeżenia w logach. W opublikowanym na blogu Stack Overflow eksperymencie zmiana limitu z dwóch CPU na jeden prawie podwoiła czas przetwarzania 200 rekordów: z 42,1 s do 83,6 s (mediany z pięciu przebiegów). Wersja z dwoma CPU przetwarzała dwa rekordy naraz, wersja z jednym — jeden. Oba warianty zapisały wszystkie 200 rekordów, więc z perspektywy poprawności wszystko działało.
Problem dotyczy zespołów, które uruchamiają usługi .NET w kontenerach z limitami CPU — czyli w praktyce większości firm wdrażających oprogramowanie na Kubernetesie lub w zarządzanych środowiskach chmurowych. Ma znaczenie, bo domyślne zachowanie runtime’u wiąże współbieżność operacji I/O z liczbą procesorów dostępnych procesowi. Przy obciążeniu opartym na oczekiwaniu na inne usługi ten związek jest technicznie nieuzasadniony, a skutki — wydłużony czas batchy, mniejsza przepustowość, wyższe koszty — łatwo pomylić ze zwykłym opóźnieniem sieciowym.
Co dokładnie się wydarzyło
Autor eksperymentu zbudował niewielkie laboratorium: kontener Docker z limitem CPU przetwarza 200 rekordów, z których każdy wymaga trzech wywołań wzbogacania (enrichment) i jednego zapisu do systemu rekordu. Pętla jest zapisana w znany sposób — Parallel.ForEachAsync(records, cancellationToken, ...) — bez dodatkowych opcji. Symulowane zależności działają w osobnym kontenerze bez limitu CPU.
W konfiguracji z dwoma CPU współbieżność wywołań wzbogacania nigdy nie przekroczyła dwóch. Przy jednym CPU — nigdy nie przekroczyła jednego. To nie jest efekt uboczny konkurencji o procesor: rekordy przez większość czasu czekają na odpowiedzi z innych usług i nie potrzebują CPU. Ograniczenie wynika wprost z domyślnej wartości MaxDegreeOfParallelism, która jest pochodną Environment.ProcessorCount.
Tło techniczne prostym językiem
Skąd bierze się limit współbieżności
Parallel.ForEachAsync bez obiektu ParallelOptions dopuszcza najwyżej Environment.ProcessorCount równoczesnych operacji. Przekazanie new ParallelOptions { CancellationToken = ct } pozostawia MaxDegreeOfParallelism na wartości początkowej -1, co dla tej metody oznacza ponownie ProcessorCount przy domyślnym schedulerze. Jawne ustawienie -1 limitu nie usuwa. To właśnie ten wariant — z samym tokenem anulowania — jest najłatwiejszy do przeoczenia, bo kod wygląda na skonfigurowany.
Jak runtime liczy procesory w kontenerze
Na Linuksie i macOS, a w Windows od .NET 6, ProcessorCount zwraca najmniejszą z trzech wartości: liczby logicznych procesorów maszyny, liczby procesorów wynikającej z affinity procesu oraz limitu wykorzystania CPU zaokrąglonego w górę do liczby całkowitej. Limit jednego CPU daje więc 1, ale limit pół CPU również daje 1 — zaokrąglenie w górę oznacza, że „połówka” nie daje żadnej przewagi nad pełnym rdzeniem z punktu widzenia tej zmiennej.
Kluczowa konsekwencja: wartość jest ustalana przy starcie runtime’u i nie zmienia się przez cały czas życia procesu. Nie da się jej „odświeżyć” po zmianie limitów kontenera — trzeba zrestartować proces. To szczegół istotny przy strojeniu: podniesienie limitu CPU w manifeście bez restartu nie zmieni zachowania pętli.
Dlaczego to nie jest problem specyficzny dla .NET
Inne środowiska również wiążą domyślne parametry z limitami kontenera, ale robią to inaczej. Go 1.25 używa limitu CPU z cgroup, a nie requestu, przy wyborze domyślnego GOMAXPROCS. JVM domyślnie wykrywa kontenery na wspieranych platformach Linux. To nie znaczy, że Go albo Java serializują pętle I/O — sedno problemu leży w kodzie, który zamienia wartość pochodną CPU na limit współbieżności operacji wejścia-wyjścia. Taka zamiana jest błędem projektowym niezależnie od języka.
Realne konsekwencje
Skutki są tym groźniejsze, że niewidoczne w metrykach błędów. Batch się kończy, rekordy są zapisywane, testy przechodzą. Bez baseline’u czasu wykonania dodatkowe oczekiwanie wygląda jak zwykłe opóźnienie usługi zewnętrznej.
- Wydłużony czas batchy — w eksperymencie prawie dwukrotnie przy przejściu z 2 CPU na 1.
- Marnowany potencjał zależności — usługa wzbogacania może obsłużyć dziesiątki równoczesnych żądań, a dostaje jedno.
- Wyższe koszty — dłużej działające zadania zużywają więcej czasu obliczeniowego i opóźniają inne etapy pipeline’u.
- Fałszywe wnioski z optymalizacji — zespół może „optymalizować” bazę danych, choć wąskim gardłem jest domyślna wartość w kodzie.
- Efekt uboczny przy skalowaniu w dół — obniżenie limitu CPU w celu oszczędności może nieproporcjonalnie pogorszyć przepustowość operacji I/O.
Scenariusze ryzyka
Nie każda pętla z tym wzorcem jest problemem. Ryzyko rośnie w określonych układach:
| Scenariusz | Poziom ryzyka | Uzasadnienie |
|---|---|---|
| Pętla I/O-heavy w kontenerze z limitem 1 CPU | Wysoki | Współbieżność spada do 1, czas oczekiwania dominuje nad pracą CPU |
| Pętla CPU-bound w kontenerze z limitem 1 CPU | Niski | Ograniczenie jest zgodne z rzeczywistą dostępnością zasobu |
| Pętla I/O w kontenerze z limitem 4+ CPU | Średni | Limit nadal obowiązuje, ale jest mniej dotkliwy; problem ujawni się przy wolnej zależności |
Pętla z jawnie ustawionym MaxDegreeOfParallelism |
Zależny od wartości | Jeśli wartość jest stałą, limit CPU nie wpływa na współbieżność; jeśli pochodną CPU — problem wraca |
| Batch o niskim priorytecie, dopuszczający opóźnienia | Niski | Wolniejsze wykonanie nie wpływa na SLA |
Osobny scenariusz to degradacja zależności. Gdy usługa zapisu zwalnia z 30 ms do 150 ms, rekordy dłużej pozostają w tym etapie. Przy stałym budżecie współbieżności oznacza to spadek przepływu — i to jest pożądane zachowanie, bo chroni zależność przed przeciążeniem. Problem pojawia się, gdy zamiast budżetu zespół podnosi współbieżność „na oko”, co prowadzi do kolejek i odrzuceń po stronie usługi.
Jak sprawdzić, czy problem dotyczy Twojego kodu
- Znajdź pętle równoległe. Przeszukaj repozytorium pod kątem
Parallel.ForEachAsync,Parallel.ForEachiParallel.For. Zwróć uwagę na wywołania bezParallelOptionsoraz takie, które przekazują tylkoCancellationToken. - Sprawdź, czy praca jest I/O-bound. Jeśli ciało pętli wykonuje wywołania HTTP, zapytania do bazy, operacje na plikach lub wywołania innych usług — to kandydat do analizy.
- Ustal limit CPU kontenera. Sprawdź manifesty wdrożeniowe:
resources.limits.cpuw Kubernetesie lub odpowiednik w konfiguracji platformy. Wartość poniżej 2 oznacza, żeProcessorCountwynosi 1. - Zmierz faktyczną współbieżność. Dodaj licznik aktywnych operacji w ciele pętli i porównaj z oczekiwaniami. Wartość maksymalna równa 1 przy limicie 1 CPU potwierdza hipotezę.
- Ustal baseline czasu wykonania. Bez punktu odniesienia nie odróżnisz spowolnienia od normalnej zmienności.
Plan reakcji krok po kroku
Krok 1: policz, ile pracy musi być w locie
Prawo Little’a wiąże trzy wielkości: liczba elementów w locie równa się przepustowości pomnożonej przez czas życia elementu. Przykład ilustracyjny z materiału źródłowego: przy trzech wywołaniach wzbogacania trwających łącznie 360 ms i zapisie 30 ms, przy celu 100 rekordów na sekundę, czas życia rekordu wynosi 0,39 s, co daje około 39 rekordów w locie. To wyliczenie poglądowe, nie pomiar laboratoryjny — ale pokazuje skalę rozbieżności: domyślne ustawienie przy jednym CPU dopuszcza jeden.
Krok 2: ustal pojemność każdej zależności
Zapytaj właścicieli usług, ile równoczesnych żądań obsłużą. Jeśli to nieznane, zwiększaj współbieżność stopniowo w środowisku testowym i obserwuj latencję oraz odrzucenia. Usługa, której czas odpowiedzi zaczyna rosnąć przy określonym obciążeniu, wyznacza górną granicę budżetu.
Krok 3: nadaj każdej zależności osobny budżet
Jeden wspólny semafor na wszystkie wywołania wychodzące ogranicza łączną współbieżność, ale nie kontroluje rozkładu między zależnościami. Wolna zależność trzyma pozwolenia dłużej i zajmuje większość wspólnej puli. Trzydzieści pozwoleń w sumie nie gwarantuje, że usługa o pojemności sześciu nie dostanie więcej niż sześć.
Rozwiązaniem jest zestaw semaforów per zależność, współdzielony przez całą pracę, którą ma ograniczać. Utworzenie nowego zestawu dla każdego rekordu dałoby każdemu rekordowi własny przydział — czyli brak limitu. W eksperymencie wariant z osobnymi budżetami (24 pozwolenia na wzbogacanie, 6 na zapis) przy spowolnionym zapisie osiągnął 35,08 zaakceptowanych rekordów na sekundę bez ani jednego odrzucenia HTTP 503. Wariant ze wspólną pulą 30 pozwoleń dał 34,01 rekordów/s i 57 odrzuceń, a wariant bez limitera — 34,35 rekordów/s i 64 odrzucenia. Mediana czasu ukończenia była przy osobnym budżecie dłuższa (około 5,7 s wobec 4,2 s), ale przepustowość użyteczna taka sama lub nieco wyższa. Porównywanie wyłącznie czasów ukończenia prowadziłoby do błędnego wniosku.
Krok 4: rozdziel limit współbieżności od limitu tempa
Semafor ogranicza liczbę wywołań w locie, ale nie egzekwuje limitu na minutę. Do kwot czasowych — w tym limitów dostawców API — potrzebny jest osobny rate limiter. Prawo Little’a pomaga oszacować współbieżność potrzebną do osiągnięcia średniego tempa, ale egzekwowanie kwoty opartej na czasie wymaga innego mechanizmu.
Krok 5: rozdziel limity czasu
Ustaw osobno limit czasu wywołania usługi i limit czasu oczekiwania na pozwolenie. Limit wywołania powinien startować po uzyskaniu pozwolenia, żeby czas spędzony w lokalnej kolejce nie zjadał budżetu zdalnego wywołania. Oczekiwanie na pozwolenie również potrzebuje własnego terminu. W eksperymencie limity czasu wywołań startowały po akwizycji, ale deadline oczekiwania na pozwolenie nie został zaimplementowany.
Krok 6: skonfiguruj jawnie i waliduj przy starcie
Limity powinny być jawną konfiguracją, a nie pochodną limitu kontenera. Jeśli limit ma znaczenie dla zależności, powinien być zapisany. Walidacja przy starcie wychwyci literówki i wartości spoza dopuszczalnego zakresu, zanim trafią na produkcję.
Krok 7: monitoruj
Śledź liczbę wywołań w locie dla każdej zależności i porównuj z skonfigurowanym przydziałem. Monitoruj też backlog po stronie klienta — przy wolnym zależności praca czeka wyżej w łańcuchu, co jest pożądanym backpressure, ale rosnąca kolejka wymaga obserwacji.
Typowe błędy
- Przekazanie samego
CancellationToken— kod wygląda na skonfigurowany, a współbieżność nadal zależy od CPU. - Jawne ustawienie
-1— nie usuwa limitu, tylko go potwierdza. - Jeden semafor na wszystko — kontroluje sumę, nie rozkład; wolna zależność zagarnia wspólną pulę.
- Nowy semafor per rekord — każdy rekord dostaje własny przydział, czyli brak limitu.
- Mylenie współbieżności z tempem — semafor nie egzekwuje kwot na minutę.
- Ocena tylko po czasie ukończenia — wariant szybszy może odrzucać żądania; liczy się przepustowość użyteczna i odrzucenia.
- Brak baseline’u — bez punktu odniesienia spowolnienie wygląda jak normalna zmienność.
- Założenie, że zmiana limitu CPU zadziała bez restartu —
ProcessorCountjest stały przez cały czas życia procesu.
Działania krótkoterminowe i długoterminowe
Krótkoterminowe (dni)
- Zidentyfikuj pętle równoległe z pracą I/O-bound w kontenerach z limitem poniżej 2 CPU.
- Dodaj pomiar maksymalnej współbieżności w ciele pętli i zbierz dane z produkcji.
- Ustal baseline czasu wykonania dla najważniejszych batchy.
- Dla potwierdzonych przypadków ustaw jawny
MaxDegreeOfParallelismna wartość wynikającą z pojemności zależności, nie z liczby CPU.
Długoterminowe (tygodnie, kwartały)
- Wprowadź budżety współbieżności per zależność jako element architektury, nie poprawkę punktową.
- Dodaj limity tempa tam, gdzie zależność ma kwoty czasowe.
- Uczyń limity jawną konfiguracją z walidacją przy starcie.
- Dodaj do code review regułę: pętla równoległa z pracą I/O wymaga jawnego uzasadnienia współbieżności.
- Uwzględnij zachowanie runtime’u w środowisku kontenerowym w dokumentacji operacyjnej zespołu.
Checklista praktyczna
- ☐ Przeszukano repozytorium pod kątem
Parallel.ForEachAsynciParallel.ForEach. - ☐ Zidentyfikowano pętle z pracą I/O-bound.
- ☐ Sprawdzono limity CPU kontenerów dla tych usług.
- ☐ Zmierzono faktyczną maksymalną współbieżność.
- ☐ Ustalono baseline czasu wykonania batchy.
- ☐ Obliczono potrzebną liczbę elementów w locie z prawa Little’a.
- ☐ Zapytano właścicieli zależności o pojemność.
- ☐ Wprowadzono osobne budżety per zależność.
- ☐ Dodano rate limiter tam, gdzie wymagane są kwoty czasowe.
- ☐ Rozdzielono limit czasu wywołania i limit czasu oczekiwania na pozwolenie.
- ☐ Limity są jawną konfiguracją z walidacją przy starcie.
- ☐ Monitorowane są wywołania w locie per zależność i backlog.
- ☐ Odrzucenia żądań są mierzone, nie tylko czas ukończenia.
Co powinien zrobić właściciel firmy / administrator
Właściciel firmy: zapytaj zespół, czy przy obniżaniu limitów CPU w celu oszczędności ktoś sprawdził wpływ na przepustowość operacji I/O. Odpowiedź „testy przeszły” nie wystarcza — testy funkcjonalne nie mierzą przepustowości. Poproś o baseline czasów wykonania dla krytycznych batchy i o dane o odrzuceniach po stronie zależności. Jeśli ich nie ma, to jest luka w obserwowalności, nie w kodzie.
Administrator / DevOps: przejrzyj manifesty wdrożeniowe pod kątem usług .NET z limitem CPU równym 1 lub poniżej. Sprawdź, czy zespoły wiedzą, że ProcessorCount jest stały przez cały czas życia procesu i że zmiana limitu wymaga restartu. Upewnij się, że metryki obejmują współbieżność wywołań wychodzących per zależność, a nie tylko ogólne opóźnienia. Przy strojeniu limitów CPU uwzględnij charakter obciążenia: dla usług I/O-bound obniżanie limitu może kosztować więcej, niż oszczędza.
Wniosek z eksperymentu jest prosty: domyślna wartość pochodna CPU ma sens dla pracy obliczeniowej, a nie dla pracy czekającej na odpowiedzi innych usług. Rozdzielenie tych dwóch przypadków wymaga jawnej decyzji projektowej — a nie polegania na tym, co runtime wyliczy przy starcie.
Praktyczna weryfikacja przed wdrożeniem
Zanim zmiany trafią na produkcję, warto potwierdzić w kontrolowanym środowisku, że nowe budżety rzeczywiście działają zgodnie z założeniami. Weryfikacja nie polega na jednorazowym uruchomieniu batcha i stwierdzeniu, że „przeszło” — chodzi o porównanie wariantów i zebranie liczb, które da się zestawić z baseline’em.
Odtwórz scenariusz z jednym CPU
Ustaw w środowisku testowym limit CPU kontenera na 1 i uruchom batch o znanym rozmiarze, najlepiej zbliżonym do produkcyjnego. W materiale źródłowym 200 rekordów przy dwóch CPU zajęło medianę 42,1 s, a przy jednym CPU — 83,6 s, przy czym oba warianty zapisały wszystkie 200 rekordów. Powtórz pomiar co najmniej pięć razy i porównuj mediany, nie pojedyncze przebiegi. Jeśli czasy są zbliżone do siebie niezależnie od limitu CPU, prawdopodobnie pętla nie jest już ograniczana przez ProcessorCount albo praca nie jest I/O-bound w takim stopniu, jak zakładano.
Zmierz faktyczną współbieżność, nie deklarowaną
Dodaj licznik inkrementowany przy wejściu do ciała pętli i dekrementowany przy wyjściu, a obok niego zapisuj maksymalną zaobserwowaną wartość. W wariancie z domyślnymi opcjami przy jednym CPU maksimum powinno wynosić 1. Następnie uruchom ten sam batch z jawnym MaxDegreeOfParallelism ustawionym na wartość wynikającą z pojemności zależności i sprawdź, czy maksimum faktycznie rośnie do oczekiwanego poziomu. To rozróżnia „skonfigurowane” od „działające”.
Porównaj warianty limitowania
Uruchom co najmniej trzy warianty: bez limitera, ze wspólnym semaforem na wszystkie wywołania wychodzące oraz z osobnymi budżetami per zależność. W eksperymencie źródłowym wariant z osobnymi budżetami (24 pozwolenia na wzbogacanie, 6 na zapis) przy spowolnionym zapisie osiągnął 35,08 zaakceptowanych rekordów na sekundę bez odrzuceń HTTP 503. Wspólna pula 30 pozwoleń dała 34,01 rekordów/s i 57 odrzuceń, a wariant bez limitera — 34,35 rekordów/s i 64 odrzucenia. Zestawienie tych trzech liczb w jednej tabeli to konkretny dowód, że rozdzielenie budżetów zmienia zachowanie systemu, a nie tylko jego konfigurację.
Sprawdź, czy pomiar nie maskuje problemu
Mediana czasu ukończenia przy osobnym budżecie była dłuższa (około 5,7 s wobec 4,2 s), mimo że przepustowość użyteczna była taka sama lub nieco wyższa. To pułapka weryfikacji: jeśli zespół patrzy wyłącznie na czas ukończenia, odrzuci lepszy wariant. W protokole weryfikacji zapisz obok siebie czas ukończenia, przepustowość zaakceptowanych rekordów i liczbę odrzuceń — dopiero razem tworzą obraz.
Monitoring po wdrożeniu
Po wdrożeniu uwaga przenosi się z konfiguracji na obserwację. Celem jest wychwycenie sytuacji, w których budżety przestały odpowiadać rzeczywistej pojemności zależności — na przykład po zmianie zachowania usługi downstream albo po obniżeniu limitu CPU w ramach oszczędności.
Metryki obowiązkowe
- Liczba wywołań w locie per zależność, zestawiona z skonfigurowanym przydziałem. Trwałe nasycenie pozwolenia oznacza, że budżet jest zbyt mały albo zależność zwolniła.
- Backlog po stronie klienta — praca czekająca wyżej w łańcuchu. Rosnąca kolejka jest pożądanym backpressure, ale jej stały wzrost wymaga reakcji.
- Odrzucenia żądań (np. HTTP 503) per zależność, mierzone osobno, a nie tylko jako ogólny wskaźnik błędów.
- Latencja wywołań per zależność, żeby odróżnić spowolnienie pojedynczej usługi od ogólnego przeciążenia.
- Czas oczekiwania na pozwolenie semafora, oddzielony od czasu samego wywołania.
Progi alertów
Alert ustaw na utrzymujące się nasycenie pozwolenia dłużej niż kilka minut, na pojawienie się odrzuceń tam, gdzie wcześniej ich nie było, oraz na wzrost backlogu bez odpowiadającego mu wzrostu przepustowości. Osobny alert dla czasu oczekiwania na pozwolenie wychwyci sytuację, w której lokalna kolejka zjada budżet, zanim wywołanie w ogóle wystartuje.
Reakcja na sygnały
- Sprawdź, czy zmiana nie wynika z obniżenia limitu CPU kontenera — ProcessorCount jest stały przez cały czas życia procesu, więc zmiana limitu wymaga restartu, a skutki pojawią się dopiero po nim.
- Porównaj bieżące metryki z baseline’em czasu wykonania batchy. Bez baseline’u spowolnienie wygląda jak zwykła zmienność.
- Zweryfikuj, czy odrzucenia koncentrują się w jednej zależności — to wskazuje na potrzebę obniżenia jej budżetu, a nie całego limitera.
- Przy utrzymującym się nasyceniu ustal z właścicielem zależności aktualną pojemność, zamiast zgadywać.
Checklisty operacyjne
Checklista wdrożeniowa
- ☐ Limity współbieżności są jawną konfiguracją, nie pochodną limitu kontenera.
- ☐ Każda zależność ma osobny budżet, współdzielony przez całą pracę, którą ma ograniczać.
- ☐ Zestaw semaforów jest tworzony raz, a nie per rekord.
- ☐ Rate limiter istnieje wszędzie tam, gdzie zależność ma kwoty czasowe.
- ☐ Limit czasu wywołania startuje po uzyskaniu pozwolenia; oczekiwanie na pozwolenie ma własny deadline.
- ☐ Konfiguracja jest walidowana przy starcie pod kątem literówek i wartości spoza zakresu.
- ☐ Metryki współbieżności per zależność i backlogu są dostępne przed włączeniem ruchu produkcyjnego.
Checklista przeglądu kodu
- ☐ Czy pętla równoległa z pracą I/O ma jawne uzasadnienie współbieżności?
- ☐ Czy przekazanie samego CancellationToken nie pozostawia współbieżności na wartości zależnej od CPU?
- ☐ Czy jawne ustawienie -1 nie jest przypadkiem potwierdzeniem limitu zamiast jego usunięcia?
- ☐ Czy nie ma jednego semafora obejmującego wszystkie wywołania wychodzące bez kontroli rozkładu?
- ☐ Czy współbieżność nie jest mylona z tempem — semafor nie egzekwuje kwot na minutę?
- ☐ Czy ocena wariantu nie opiera się wyłącznie na czasie ukończenia, pomijając odrzucenia i przepustowość użyteczną?
Checklista audytu środowiska
- ☐ Manifesty wdrożeniowe usług .NET z limitem CPU równym 1 lub poniżej są zidentyfikowane.
- ☐ Zespoły wiedzą, że ProcessorCount jest stały przez cały czas życia procesu i że zmiana limitu wymaga restartu.
- ☐ Metryki obejmują współbieżność wywołań wychodzących per zależność, a nie tylko ogólne opóźnienia.
- ☐ Przy strojeniu limitów CPU uwzględniono charakter obciążenia — dla usług I/O-bound obniżka może kosztować więcej, niż oszczędza.
- ☐ Baseline czasów wykonania krytycznych batchy istnieje i jest aktualizowany po istotnych zmianach.
Jak odróżnić regresję od normalnej zmienności
Spowolnienie po wdrożeniu nie zawsze oznacza błąd konfiguracji. W materiale źródłowym podkreślono, że batch nadal się kończy i każdy rekord zostaje zapisany — bez baseline’u dodatkowe oczekiwanie wygląda jak zwykła latencja usługi. Dlatego punktem odniesienia powinien być ustalony wcześniej czas wykonania dla konkretnego rozmiaru batcha, a nie ogólne wrażenie, że „działa podobnie”.
Praktyczna reguła: jeśli czas wykonania wzrósł, a liczba odrzuceń i przepustowość użyteczna się nie zmieniły, prawdopodobnie wzrosła lokalna kolejka lub wydłużył się czas oczekiwania na pozwolenie — to nie musi być regresja, ale wymaga potwierdzenia metrykami. Jeśli wzrosły odrzucenia, problem leży w budżecie zależności albo w jej faktycznej pojemności. Jeśli spadła zarówno przepustowość użyteczna, jak i wzrosły odrzucenia, wariant limitowania jest źle dobrany i trzeba wrócić do porównania wariantów z etapu weryfikacji.
Źródła i materiały do dalszej weryfikacji
Artykuł jest autorskim opracowaniem przygotowanym na podstawie poniższych materiałów. Linki prowadzą do publikacji źródłowych.
- Your .NET parallel loop can become serial in a one-CPU container (stackoverflow.blog)
Zdjęcie wyróżniające: panumas nikhomkhai / Pexels.


