Zrozumienie blokady globalnego tłumacza Pythona
Published: 2024-01-26 16:19:07

Czym jest globalna blokada interpretera (GIL) w Pythonie?
---------------------------------------------------------

W świecie Pythona czai się niesławne stworzenie znane jako Global Interpreter Lock (GIL), wpływające na wydajność i wątkowanie. Gdy programiści zagłębiają się w serce Pythona, aby zrozumieć, rzucić wyzwanie i potencjalnie przekroczyć GIL, napotykają zarówno jego ograniczenia, jak i wpływ na implementację Pythona w różnych domenach, w tym w nauce o danych i uczeniu maszynowym.

### Aktualizacja od Redditora [zurtex](https://www.reddit.com/user/zurtex/) na temat wyłączania GIL

[Zobacz komentarz zurtexa na reddicie](https://www.reddit.com/r/Python/comments/15i5je7/comment/juu7usg/)

Opcja `--disable-gil` nie jest dostępna dla CPython 3.12. W rzeczywistości gałąź CPython 3.12 jest teraz zablokowana dla commitów spoza zespołu zarządzającego wydaniami, ponieważ przygotowują się do wydania rc1.

Co więcej, tak duża zmiana wylądowałaby tylko w gałęzi głównej (obecnie 3.13), a nie bezpośrednio w gałęzi wersji mniejszej, gdy ta gałąź zostanie oddzielona od głównej, co miało miejsce kilka miesięcy temu dla 3.12, na długo przed ogłoszeniem zamiaru zaakceptowania PEP.

PEP 703 _może_ wylądować w CPython 3.13, ale Rada Sterująca była całkiem jasna, że nie ma problemu z przesunięciem go do CPython 3.14. Może się więc mylić, mówiąc, że wyląduje_"wkrótce_":

-   PEP 703 jest w wersji **roboczej**, nie został jeszcze oficjalnie zaakceptowany
    
-   Sam Gross jest teraz na wakacjach i miałby dużo pracy z przywróceniem [gałęzi nogil](https://github.com/colesbury/nogil-3.12) do głównej i przynajmniej zaadresowaniem kilku problemów podniesionych przez zespół Faster CPython, które mogą powodować awarie przy użyciu czystego kodu Pythona, zanim będzie można uznać, że wyląduje w głównej.
    

CPython 3.12 wyłącza globalną blokadę tłumacza (GIL)
----------------------------------------------------

Skrypt `./configure` może _wkrótce_ ustawić makro `Py_NOGIL` w pliku `Python/patchlevel.h`. Oznacza to, że sposób na wyłączenie GIL wygląda następująco:

```js
git clone -b nogil-3.12 https://github.com/colesbury/nogil-3.12.git
cd nogil-3.12
./configure --disable-gil
make
```

_Flaga__`--disable-gil`_ jest _wersją roboczą PEP. Nawet jeśli mówi, że jest nierozpoznana, powyższe polecenia utworzą pliki binarne z wyłączonym GIL._

Wyłącz GIL**w czasie kompilacji: https:**[//peps.python.org/pep-0703/#build-configuration-changes](https://peps.python.org/pep-0703/#build-configuration-changes)

**Ponowne włączenie**GIL w czasie wykonywania:[https:](https://peps.python.org/pep-0703/#pythongil-environment-variable) //peps.python.org/pep-0703/#pythongil-environment-variable

Pochodzenie i cel Python GIL oraz rola Global Interpreter Lock
--------------------------------------------------------------

Pierwotnie wprowadzony w Pythonie 1.5, GIL był mechanizmem zaprojektowanym w celu poprawy stabilności. Zasadniczo jest to muteks (lub blokada), który pozwala tylko jednemu wątkowi na wykonywanie kodu bajtowego Pythona w danym czasie. Było to przede wszystkim rozwiązanie do obsługi wielowątkowości i ułatwienia zarządzania pamięcią, tworząc poczucie bezpieczeństwa i przewidywalności w środowisku Pythona.

Ograniczenie globalnej blokady interpretera Pythona (GIL)
---------------------------------------------------------

Ten mechanizm bezpieczeństwa miał jednak swoją cenę. Pomimo swojego pierwotnego przeznaczenia, GIL stał się źródłem przeszkód dla wydajności, powodując, że programy Pythona przestawały reagować podczas operacji I/O lub wywołań systemowych.

Wielowątkowość Pythona stała się praktycznie bezużyteczna dla zadań intensywnie wykorzystujących procesor z powodu tej blokady, tworząc poważną przeszkodę. Pomimo prostoty i bezpieczeństwa, jakie zapewniała, zostaliśmy wezwani do przygody, aby rzucić wyzwanie i pokonać to ograniczenie.

Biblioteki asynchroniczne i wieloprocesowość: najlepsi przyjaciele współbieżności Pythona
-----------------------------------------------------------------------------------------

Przed zakwestionowaniem samego GIL, początkową reakcją było złagodzenie jego ograniczeń. Dla zadań o wysokiej współbieżności wprowadzono asynchroniczne biblioteki I/O. Biblioteki te pozwalają na wykonywanie operacji I/O i wywołań systemowych bez ingerencji w GIL.

W przypadku obciążeń procesora pojawił się multiprocessing, pozwalający wielu środowiskom wykonawczym Pythona działać jednocześnie. Było to możliwe dzięki mechanizmowi przekazywania komunikatów, w którym wątki mogły komunikować się i współdzielić obciążenia. Narzędzia te stanowiły obejście dla GIL, pozwalając go uniknąć. Biblioteki te nie rozwiązują jednak podstawowego problemu GIL.Badanie alternatyw dla CPythona, takich jak [IronPython](https://ironpython.net/) i [Jython](https://www.jython.org/), ujawnia, jak różnie radzą sobie one z wielowątkowością. IronPython, na przykład, integruje się z frameworkiem .NET i korzysta z jego modelu wątków, podczas gdy Jython, który działa na wirtualnej maszynie Javy, wykorzystuje możliwości wątków Javy. Te implementacje Pythona oferują wgląd w różne podejścia do współbieżności, pokazując wszechstronność języka programowania w dostosowywaniu się do różnych platform i środowisk.

Decyzja o wyłączeniu py.GIL: przygotuj się, zaczyna się wyzwanie
----------------------------------------------------------------

Wraz z wydaniem CPython 3.12 podróż przybrała ekscytujący obrót - GIL można było teraz wyłączyć. To przedsięwzięcie, wymagające ponownej kompilacji Pythona z flagą `--disable-gil`, obiecywało dramatyczny potencjalny wzrost wydajności. Jednak wprowadziło nas również na znacznie bardziej ryzykowne terytorium. Jakie byłyby konsekwencje tak radykalnego posunięcia?

Konsekwencje wyłączenia GIL w Pythonie: bezpieczeństwo jest wyłączone
---------------------------------------------------------------------

Wyłączenie Global Interpreter Lock umożliwiło wielu wątkom jednoczesne wykonywanie kodu bajtowego Pythona. Oznaczało to możliwość potencjalnego znacznego zwiększenia wydajności. Ryzyko było jednak znaczne; całkowicie usuwało wbudowaną osłonę bezpieczeństwa Pythona, robiąc miejsce potencjalnym awariom z powodu problemów z zasobami współdzielonymi i obsługą pamięci.

Prawdziwe wątki w Pythonie: prawdziwe korzyści
----------------------------------------------

Po wyłączeniu GIL mogliśmy teraz rozważyć bardziej nowatorskie wykorzystanie wątków. Nawet zadania wymagające dużej mocy obliczeniowej procesora można było podzielić na wątki, co można uznać za znaczącą nagrodę za tę mękę. Wymagało to jednak skrupulatnego obchodzenia się ze współdzieloną pamięcią i zasobami, w przeciwnym razie mogłoby to doprowadzić do katastrofy - skutecznie uwolniliśmy Pythona od jego ograniczeń bezpieczeństwa.

Na wynos i wnioski dotyczące Python GIL
---------------------------------------

Pomimo emocji i możliwości związanych z wyłączeniem GIL, stało się jasne, że oryginalny projekt Pythona ma swoje zalety. Podczas gdy jego ograniczenia były rażące, GIL zapewniał również ochronę przed potencjalnymi awariami, zapewniając ogólną stabilność systemu.

Wyłączenie GIL może potencjalnie poprawić wydajność i wiąże się ze znacznym ryzykiem. Właściwe zrozumienie i środki ostrożności są niezbędne przed wkroczeniem na to nowe terytorium. Mądrzej jest optymalizować w ramach modelu wątków Pythona, wykorzystując asynchroniczne biblioteki I/O i wieloprocesowość, niż od razu wyłączać GIL.

Przygoda z GIL Pythona przynosi nie tylko potencjalne rozwiązanie, ale także głębsze zrozumienie całego systemu, promując bardziej przemyślany i skomplikowany sposób angażowania się w Pythona. Korzystanie z najlepszych dostępnych narzędzi i unikanie kar za wydajność wynikających z GIL jest możliwe.

Moje przemyślenia na temat Python GIL
-------------------------------------

Początkowo byłem podekscytowany możliwością wyłączenia globalnej blokady interpretera (GIL) w Pythonie, ponieważ obiecywało to nowe możliwości wzrostu wydajności. Jednak po głębszym zastanowieniu uważam, że tak nie jest. Wyłączenie GIL pozwoliłoby jedynie na wykorzystanie wzorców wątków i wątków w Pythonie, których nie jestem fanem. Moją preferowaną metodą na osiągnięcie wysokiej współbieżności i wydajnych programów jest użycie wielu procesów z przekazywaniem komunikatów.

W ten sposób zaprojektowaliśmy PubNub, który obecnie ma wiele klastrów Kubernetes rozproszonych po całym świecie i obsługuje ponad 1 miliard urządzeń w sieci. Jesteśmy w stanie osiągnąć ten poziom współbieżności i skalowalności, stosując wzorce, które pozwalają nam w pełni wykorzystać zasoby, które kupujemy od naszego dostawcy usług w chmurze, Amazon Web Services. Nie musimy martwić się o wątki, blokady lub bezpieczeństwo pamięci, ponieważ ten wzorzec projektowy jest zaimplementowany w języku C, wykorzystując asynchroniczne przerwania I/O jądra bezpośrednio przez interfejs API jądra epoll w systemie Linux. Pozwala nam to w pełni wykorzystać możliwości naszego procesora bez konieczności wykonywania kontekstu.

Ten sam efekt można osiągnąć w Pythonie. Uruchamiając jednowątkowy worker Pythona w kontenerze Docker, a następnie uruchamiając wiele kontenerów Docker. Możesz zaokrąglać i równoważyć obciążenie za pomocą load balancera, takiego jak [Nginx](https://www.pubnub.com/guides/nginx/), który jest powszechnym standardowym load balancerem używanym w ekosystemie Kubernetes. Pozwoli to osiągnąć to, czego potrzebujesz. Będziesz chciał dodać asynchroniczną bibliotekę I/O, aby silnik Pythona nie blokował się podczas oczekiwania na I/O. Pozwoli to w pełni wykorzystać możliwości zakupionego sprzętu.

Jeśli chcesz po prostu skorzystać ze współbieżności na pojedynczym systemie, takim jak laptop, użycie biblioteki wieloprocesowej Pythona jest najlepszym rozwiązaniem. Zapewnia ona mechanizmy dystrybucji obciążeń na rdzenie CPU w systemie.

Python 3.12 GIL - najczęściej zadawane pytania
----------------------------------------------

Musimy omówić kilka dodatkowych elementów w odniesieniu do tego, co możesz zrobić dalej. Oto kilka często zadawanych pytań, które pojawiły się podczas dyskusji.

### Czy powinienem być podekscytowany Pythonem 3.12 i nową flagą --disable-gil?

1.  Tak, jeśli lubisz wątki i pracę z wyzwaniami i dodatkowym kodem.
    
2.  **W przeciwnym razie nie. Są lepsze opcje!**
    

To, czy być podekscytowanym Pythonem 3.12 i nową flagą `--disable-gil`, zależy w dużej mierze od konkretnego przypadku użycia i zrozumienia złożoności wielowątkowości.

Jeśli często angażujesz się w zadania intensywnie wykorzystujące procesor i jesteś biegły w ostrożnym zarządzaniu wątkami i programowaniu, opcja wyłączenia Global Interpreter Lock (GIL) może być korzystna. Funkcja ta może potencjalnie przynieść znaczny wzrost wydajności, ponieważ wiele wątków może jednocześnie wykonywać kod bajtowy Pythona bez spowalniania ich przez GIL.

Funkcja ta zwiększa również ryzyko. GIL w Pythonie odgrywa kluczową rolę w utrzymywaniu integralności obiektów Pythona poprzez zapobieganie jednoczesnemu wykonywaniu kodu bajtowego Pythona przez wiele wątków. Rozwijanie programów wątkowych bez GIL wymaga dogłębnego zrozumienia bezpieczeństwa wątków i synchronizacji, ponieważ to na tobie spoczywa teraz odpowiedzialność za zapewnienie, że nie wystąpią wyścigi danych lub niespójności.

Wiele standardowych bibliotek Pythona polega na istnieniu GIL w celu zapewnienia bezpieczeństwa wątków i mogą one nie działać poprawnie - lub wcale - jeśli zdecydujesz się je wyłączyć.

Tak więc, choć funkcja ta może potencjalnie oferować znaczną poprawę wydajności w określonych kontekstach, nie jest to coś, czego należy używać lekkomyślnie lub uniwersalnie. Podobnie jak w przypadku każdego potężnego narzędzia, wymaga ono zrozumienia, szacunku i ostrożności, aby używać go prawidłowo i skutecznie.

Dla większości programistów Pythona, zwłaszcza tych, którzy nie tworzą wielowątkowych aplikacji intensywnie wykorzystujących procesor, pojawienie się bibliotek asynchronicznych i modułów wieloprocesorowych w bibliotece standardowej Pythona zapewnia wystarczające mechanizmy obsługi współbieżności i równoległości, dzięki czemu wyłączenie GIL jest mniej istotne.

### Co staje się dostępne po wyłączeniu GIL?

Wyłączenie Global Interpreter Lock (GIL) przede wszystkim umożliwia wielordzeniowym programom Pythona osiągnięcie prawdziwie współbieżnego wykonywania wątków, potencjalnie prowadząc do znacznej poprawy wydajności zadań związanych z procesorem.

Oto krótkie podsumowanie tego, co staje się dostępne po wyłączeniu GIL:

1.  **Współbieżne wykonywanie wątków:** Z wyłączonym GIL, wiele wątków może wykonywać bajtkody Pythona współbieżnie bez oczekiwania na blokadę. Może to prowadzić do lepszego wykorzystania procesorów wielordzeniowych.
    
2.  **Lepsza wydajność dla wielowątkowych zadań związanych z CPU:** W przypadku zadań związanych z procesorem, które zostały podzielone na wiele wątków, wyłączenie GIL może potencjalnie prowadzić do znacznej poprawy wydajności, ponieważ każdy wątek może być wykonywany jednocześnie na różnych rdzeniach.
    
3.  **Większa kontrola nad synchronizacją wątków:** Wyłączenie GIL oznacza, że deweloperzy muszą teraz sami zająć się synchronizacją wątków. Chociaż wymaga to głębokiego zrozumienia wielowątkowości, daje również większą kontrolę nad operacjami wątków i może potencjalnie pozwolić na bardziej zniuansowane i zoptymalizowane dostrajanie wydajności.
    

Ważne jest, aby zdawać sobie sprawę z potencjalnych minusów. Wyłączenie GIL usuwa zabezpieczenie, które zapewnia bezpieczne działanie wątków dla wielu bibliotek i operacji Pythona. W związku z tym złożoność i potencjalne pułapki związane z wielowątkowością, takie jak warunki wyścigu, zakleszczenia i inne kwestie związane z synchronizacją, stają się obowiązkiem dewelopera.

### Czy zobaczę poprawę wydajności po wyłączeniu GIL?

To, czy zauważysz poprawę wydajności po wyłączeniu globalnej blokady interpretera (GIL), zależy od charakteru twojego programu w Pythonie.

Jeśli twój program w dużym stopniu wykorzystuje zadania związane z procesorem i został zaprojektowany przy użyciu wielowątkowości, możesz potencjalnie zauważyć znaczną poprawę wydajności. Wynika to z faktu, że przy wyłączonym GIL wiele wątków może wykonywać kody bajtowe Pythona na różnych rdzeniach w tym samym czasie, co prowadzi do lepszego wykorzystania procesorów wielordzeniowych.

Jeśli twój program jest głównie związany z I/O (na przykład spędza większość czasu czekając na odpowiedzi sieciowe, czytając z dysku, itp.), to GIL jest mniej prawdopodobne, aby być wąskim gardłem i wyłączenie go prawdopodobnie przyniosłoby minimalną, jeśli w ogóle, poprawę wydajności. W rzeczywistości, w scenariuszach związanych z I/O, właściwe wykorzystanie programowania asynchronicznego i bibliotek współbieżności może być bardziej korzystne niż wyłączenie GIL.

Jeśli program nie został zaprojektowany do prawidłowego zarządzania synchronizacją wątków, wyłączenie GIL może w rzeczywistości obniżyć wydajność lub spowodować nieoczekiwane zachowanie z powodu warunków wyścigu i innych pułapek związanych z wielowątkowością.

Podczas gdy istnieje możliwość zwiększenia wydajności poprzez wyłączenie GIL w określonych scenariuszach, do bezpiecznego i skutecznego zarządzania prawdziwą wielowątkowością w Pythonie bez GIL potrzebna jest znaczna ostrożność i wiedza specjalistyczna. W przypadku wielu aplikacji bezpieczniejszym i skuteczniejszym podejściem może być wykorzystanie innych funkcji Pythona, takich jak moduł wieloprocesowy lub asynchroniczne IO do zarządzania równoległymi i współbieżnymi zadaniami.

### Jak wyłączyć GIL?

Aby wyłączyć Global Interpreter Lock (GIL) w Pythonie, należy skonfigurować i zbudować Pythona z flagą --disable-gil. Jako warunek wstępny, ta metoda wymaga kompilacji Pythona ze źródła. Ponadto należy pamiętać, że funkcja umożliwiająca wyłączenie GIL znajduje się w CPython w wersji 3.14 i nowszych. Oto kroki:

1\. Pobierz plik źródłowy CPython dla Pythona 3.1X lub nowszego. Bardziej prawdopodobne jest, że będzie to Python 3.14. Możesz sklonować repozytorium z Githuba.

`git clone -b 3.1X https://github.com/python/cpython.git`

2\. Przejdź do pobranego katalogu CPython.

`cd cpython`

3\. Uruchom skrypt configure z flagą --disable-gil.

`./configure --disable-gil`

4\. Teraz zbuduj Pythona.

`make`

Nie należy tego robić lekkomyślnie, ponieważ może to potencjalnie prowadzić do problemów z wątkami, jeśli kod nie jest odpowiednio bezpieczny dla wątków. Jest to bardziej odpowiednie dla programistów, którzy potrzebują prawdziwej wielowątkowości i są przygotowani do radzenia sobie ze złożonością, która pojawia się, gdy bezpieczeństwo wątków nie jest gwarantowane przez Pythona. Przed wyłączeniem GIL należy zawsze upewnić się, że kod i wszystkie używane biblioteki są bezpieczne dla wątków.

### Jak ponownie włączyć GIL za pomocą zmiennej środowiskowej?

Globalna blokada interpretera Pythona (GIL) może zostać ponownie włączona poprzez ustawienie zmiennej środowiskowej o nazwie PYTHONGIL na 1. Działa to jako nadpisanie wymuszające ponowne włączenie GIL, nawet jeśli został on wyłączony w czasie kompilacji.

Ustawienie zmiennej można wykonać na różne sposoby w zależności od systemu operacyjnego. Oto jak to zrobić w systemach uniksowych, w tym Linux i MacOS:

`export PYTHONGIL=1`

`python my-app.py`

W systemach Windows można ustawić zmienne środowiskowe za pomocą polecenia:

`set PYTHONGIL=1`

`python my-app.py`

Należy pamiętać, że te polecenia ustawią zmienną środowiskową tylko dla bieżącej sesji terminala. Jeśli chcesz ustawić ją na stałe, musisz dodać odpowiednie polecenie do pliku inicjalizacyjnego powłoki (np. .bashrc lub .bash\_profile dla powłoki bash w systemach uniksowych) lub ustawić zmienną we właściwościach systemu w systemie Windows.

Pamiętaj, że musisz uruchomić swój program Python z tej samej sesji terminala, w której ustawiłeś tę zmienną środowiskową, aby zobaczyć jej wpływ na program.

### Czy istnieje ryzyko związane z wyłączeniem GIL?

Tak, istnieje znaczne ryzyko związane z wyłączeniem Global Interpreter Lock (GIL) w Pythonie. Poniżej wymieniono najważniejsze z nich:

1.  **Kwestie bezpieczeństwa wątków:** GIL zapewnia pewien stopień bezpieczeństwa wątków, nie pozwalając wielu wątkom na jednoczesne wykonywanie kodu bajtowego Pythona. Wyłączając GIL, odpowiedzialność za zapewnienie bezpieczeństwa wątków spada na programistę. Może to wprowadzić takie problemy, jak warunki wyścigu, uszkodzenie danych i awarie, jeśli wiele wątków jednocześnie uzyskuje dostęp do współdzielonych danych lub modyfikuje je bez odpowiedniej synchronizacji.
    
2.  **Problemy z kompatybilnością:** Wiele bibliotek Pythona, w tym niektóre w bibliotece standardowej, zostało napisanych przy założeniu, że GIL jest włączony. Biblioteki te mogą wykorzystywać operacje typu thread-unsafe, które są bezpieczne pod GIL, ale mogą powodować problemy, gdy GIL jest wyłączone.
    
3.  **Spadek wydajności: W**niektórych przypadkach wyłączenie GIL może faktycznie obniżyć wydajność ze względu na zwiększony narzut związany z zarządzaniem wieloma wątkami i synchronizacją dostępu do współdzielonych danych.
    
4.  **Trudności w debugowaniu:** Debugowanie aplikacji wielowątkowych bez GIL może być bardziej skomplikowane ze względu na dodatkową synchronizację wątków, którą należy zapewnić ręcznie.
    
5.  **Ryzyko Deadlocków:** Bez GIL możesz być również bardziej podatny na napotkanie martwych punktów, w których dwa lub więcej wątków w nieskończoność czeka, aż drugi zwolni zasób.
    

Wyłączenie GIL może potencjalnie zwiększyć wydajność niektórych aplikacji wielowątkowych związanych z procesorem, ale jest uważane za ryzykowne posunięcie i zazwyczaj nie jest zalecane, chyba że jesteś dobrze zaznajomiony z synchronizacją wątków i jesteś przygotowany do zarządzania złożonością i potencjalnymi pułapkami wielowątkowości.

### Czy istnieją alternatywy dla wyłączenia GIL?

Tak, istnieje kilka innych sposobów na obsługę współbieżnego i równoległego przetwarzania w Pythonie bez konieczności wyłączania Globalnej Blokady Interpretera (GIL):

1.  **Wielowątkowość:** W przypadku zadań, które są w dużej mierze związane z wejściami/wyjściami (takich jak wykonywanie wielu żądań internetowych, odczytywanie z pliku lub bazy danych itp. GIL jest wąskim gardłem dla zadań związanych z CPU, ale zadania związane z I/O mogą zwolnić GIL i pozwolić innym wątkom działać, gdy czekają na I/O.
    
2.  **Wieloprzetwarzanie:** Moduł wieloprzetwarzania w Pythonie omija GIL poprzez tworzenie oddzielnych procesów interpretera Pythona, a zatem pozwala na prawdziwą równoległość w zadaniach związanych z procesorem. Wiąże się to z narzutem komunikacji międzyprocesowej i może zużywać znacznie więcej pamięci, ale jest to solidny sposób na obejście GIL.
    
3.  **Programowanie asynchroniczne:** Moduł asyncio Pythona i biblioteki asynchroniczne, takie jak Twisted i Tornado, pozwalają na bardziej wydajną obsługę wielu zadań związanych z I/O przy użyciu pętli zdarzeń. Model ten może w pełni wykorzystać czas oczekiwania związany z zadaniami I/O do wykonania innych zadań, a tym samym poprawić przepustowość programu.
    
4.  **NumPy/SciPy do przetwarzania numerycznego:** Biblioteki te tłumaczą znaczną część swoich obliczeń na skompilowany kod, w którym można uniknąć GIL, dzięki czemu doskonale nadają się do obliczeń numerycznych i są dobrze zoptymalizowane pod kątem operacji wektorowych.
    
5.  **Rozszerzenia Cython lub C:** Jeśli wydajność ma krytyczne znaczenie, można napisać rozszerzenia C lub użyć Cythona do napisania części kodu na poziomie C. W natywnym kodzie C, GIL może zostać uwolniony, łagodząc w ten sposób jego wady.
    
6.  **Biblioteki do obliczeń równoległych:** Narzędzia takie jak joblib, Dask, Ray i inne zapewniają środowiska wyższego poziomu do wykonywania obliczeń równoległych, które mogą wykorzystywać wiele procesorów i efektywnie zarządzać współdzieleniem pamięci.
    

Najlepsza alternatywa zależy od konkretnego przypadku i rodzaju problemu, który próbujesz rozwiązać. Zawsze ważne jest, aby zrozumieć kompromisy dla każdej opcji, aby upewnić się, że dokonujesz wyboru, który najlepiej odpowiada Twoim wymaganiom.

Jak PubNub może ci pomóc?
=========================

Ten artykuł został pierwotnie opublikowany na [PubNub.com](https://www.pubnub.com/blog/understanding-pythons-global-interpreter-lock/)

Nasza platforma pomaga programistom tworzyć, dostarczać i zarządzać interaktywnością w czasie rzeczywistym dla aplikacji internetowych, aplikacji mobilnych i urządzeń IoT.

Fundamentem naszej platformy jest największa w branży i najbardziej skalowalna sieć przesyłania wiadomości w czasie rzeczywistym. Dzięki ponad 15 punktom obecności na całym świecie obsługującym 800 milionów aktywnych użytkowników miesięcznie i niezawodności na poziomie 99,999%, nigdy nie będziesz musiał martwić się o przestoje, limity współbieżności lub jakiekolwiek opóźnienia spowodowane skokami ruchu.

Poznaj PubNub
-------------

Sprawdź [Live Tour](https://www.pubnub.com/tour/introduction/), aby zrozumieć podstawowe koncepcje każdej aplikacji opartej na PubNub w mniej niż 5 minut.

Rozpocznij konfigurację
-----------------------

Załóż [konto](https://admin.pubnub.com/signup/) PubNub, aby uzyskać natychmiastowy i bezpłatny dostęp do kluczy PubNub.

Rozpocznij
----------

[Dokumenty](https://www.pubnub.com/docs) PubNub pozwolą Ci rozpocząć pracę, niezależnie od przypadku użycia lub [zestawu SDK](https://www.pubnub.com/docs).