Çoklu iş parçacığı Python Örnek ile: GIL'yi öğrenin Python

Python programlama dili, çoklu işleme veya çoklu iş parçacığı kullanmanıza olanak tanır. Bu eğitimde, çoklu iş parçacıklı uygulamaları nasıl yazacağınızı öğreneceksiniz. Python.

Konu Nedir?

Bir iş parçacığı eşzamanlı programlamada bir yürütme birimidir. Çoklu iş parçacığı, CPU'nun bir işlemin birçok görevini aynı anda yürütmesine olanak tanıyan bir tekniktir. Bu iş parçacıkları, süreç kaynaklarını paylaşırken ayrı ayrı yürütülebilir.

Süreç Nedir?

Bir süreç temel olarak yürütülmekte olan programdır. Bilgisayarınızda bir uygulamayı başlattığınızda (tarayıcı veya metin düzenleyici gibi), işletim sistemi bir proses.

Çoklu iş parçacığı nedir? Python?

Çoklu iş parçacığı Python programlama, bir süreçteki birden fazla iş parçacığının veri alanlarını ana iş parçacığıyla paylaştığı, iş parçacıkları içindeki bilgi paylaşımını ve iletişimi kolay ve verimli hale getiren iyi bilinen bir tekniktir. İplikler işlemlerden daha hafiftir. Çoklu iş parçacıkları, süreç kaynaklarını paylaşırken ayrı ayrı yürütülebilir. Çoklu iş parçacığının amacı birden fazla görevi ve işlev hücresini aynı anda çalıştırmaktır.

Çoklu İşleme Nedir?

Çoklu İşlem birden fazla ilgisiz işlemi aynı anda çalıştırmanıza olanak tanır. Bu işlemler kaynaklarını paylaşmaz ve IPC aracılığıyla iletişim kurar.

Python Çoklu iş parçacığı vs Çoklu işlem

İşlemleri ve iş parçacıklarını anlamak için şu senaryoyu göz önünde bulundurun: Bilgisayarınızdaki bir .exe dosyası bir programdır. Açtığınızda, işletim sistemi onu belleğe yükler ve CPU onu çalıştırır. Programın şu anda çalışmakta olan örneğine süreç denir.

Her sürecin 2 temel bileşeni olacaktır:

• Kod
• Veri

Artık bir süreç, adı verilen bir veya daha fazla alt parça içerebilir. İş Parçacığı. Bu işletim sistemi mimarisine bağlıdır. Bir iş parçacığını, işletim sistemi tarafından ayrı olarak yürütülebilen bir işlem bölümü olarak düşünebilirsiniz.

Başka bir deyişle, işletim sistemi tarafından bağımsız olarak çalıştırılabilen bir talimat akışıdır. Tek bir süreçteki iş parçacıkları o sürecin verilerini paylaşır ve paralelliği kolaylaştırmak için birlikte çalışacak şekilde tasarlanmıştır.

Neden Çoklu İş Parçacığı kullanmalı?

Çoklu iş parçacığı, bir uygulamayı birden fazla alt göreve bölmenize ve bu görevleri aynı anda çalıştırmanıza olanak tanır. Çoklu iş parçacığını doğru şekilde kullanırsanız, uygulama hızınız, performansınız ve işlemeniz iyileştirilebilir.

Python Çoklu İş Parçacığı

Python hem çoklu işleme hem de çoklu iş parçacığına yönelik yapıları destekler. Bu eğitimde öncelikle uygulamaya odaklanacaksınız. okuyuculu Python ile uygulamalar. İş parçacıklarını işlemek için kullanılabilen iki ana modül vardır Python:

1. The iplik modül ve
2. The threading modül

Ancak python'da global yorumlayıcı kilidi (GIL) adı verilen bir şey de vardır. Çok fazla performans artışına izin vermez ve hatta azaltmak bazı çok iş parçacıklı uygulamaların performansı. Bu eğitimin gelecek bölümlerinde bununla ilgili her şeyi öğreneceksiniz.

Thread ve Threading modülleri

Bu eğitimde öğreneceğiniz iki modül şunlardır: iplik modülü ve iş parçacığı modülü.

Ancak iş parçacığı modülü uzun süredir kullanımdan kaldırılmıştır. Şununla başlıyor: Python 3, eski olarak belirlenmiş ve yalnızca şu şekilde erişilebilir: __Konu geriye dönük uyumluluk için.

Daha üst seviyeyi kullanmalısınız threading dağıtmayı düşündüğünüz uygulamalar için modül. İş parçacığı modülü burada yalnızca eğitim amaçlı ele alınmıştır.

Konu Modülü

Bu modülü kullanarak yeni bir iş parçacığı oluşturmanın sözdizimi aşağıdaki gibidir:

thread.start_new_thread(function_name, arguments)

Tamam, artık kodlamaya başlamanın temel teorisini öğrendiniz. Öyleyse aç IDLE veya bir not defterine yazın ve şunları yazın:

import time
import _thread

def thread_test(name, wait):
   i = 0
   while i <= 3:
      time.sleep(wait)
      print("Running %s\n" %name)
      i = i + 1

   print("%s has finished execution" %name)

if __name__ == "__main__":
    
    _thread.start_new_thread(thread_test, ("First Thread", 1))
    _thread.start_new_thread(thread_test, ("Second Thread", 2))
    _thread.start_new_thread(thread_test, ("Third Thread", 3))

Dosyayı kaydedin ve programı çalıştırmak için F5 tuşuna basın. Her şey doğru yapıldıysa görmeniz gereken çıktı şudur:

Gelecek bölümlerde yarış koşulları ve bunlarla nasıl başa çıkılacağı hakkında daha fazla bilgi edineceksiniz.

KOD AÇIKLAMA

1. Bu ifadeler, yürütmeyi ve gecikmeyi işlemek için kullanılan zaman ve iş parçacığı modülünü içe aktarır. Python İş Parçacığı.
2. Burada, adı verilen bir işlevi tanımladınız. thread_test, tarafından çağrılacak start_new_thread yöntem. İşlev, dört yineleme boyunca bir while döngüsü çalıştırır ve onu çağıran iş parçacığının adını yazdırır. Yineleme tamamlandığında, iş parçacığının yürütülmesinin tamamlandığını belirten bir mesaj yazdırır.
3. Bu programınızın ana bölümüdür. Burada aramanız yeterli start_new_thread ile yöntem iş parçacığı_testi argüman olarak işlev. Bu, argüman olarak ilettiğiniz işlev için yeni bir iş parçacığı oluşturacak ve onu çalıştırmaya başlayacaktır. Bunu değiştirebileceğinizi unutmayın (iş parçacığı_test) iş parçacığı olarak çalıştırmak istediğiniz herhangi bir işlevle kullanın.

Diş Açma Modülü

Bu modül, python'da iş parçacığının üst düzey uygulamasıdır ve çok iş parçacıklı uygulamaları yönetmek için fiili standarttır. İş parçacığı modülüyle karşılaştırıldığında geniş bir özellik yelpazesi sunar.

Bu modülde tanımlanan bazı yararlı işlevlerin listesi aşağıda verilmiştir:

Fonksiyon adı	Açıklama
aktifSayı()	Sayısını döndürür Konu hala hayatta olan nesneler
currentThread()	Thread sınıfının geçerli nesnesini döndürür.
numaralandırmak()	Tüm etkin Thread nesnelerini listeler.
isDaemon()	İş parçacığı bir daemon ise true değerini döndürür.
yaşıyor()	İş parçacığı hala hayattaysa true değerini döndürür.
	Konu Sınıfı yöntemleri
Başlat()	Bir iş parçacığının etkinliğini başlatır. Her iş parçacığı için yalnızca bir kez çağrılmalıdır çünkü birden çok kez çağrılırsa çalışma zamanı hatası verir.
Çalıştırmak()	Bu yöntem bir iş parçacığının etkinliğini belirtir ve İş Parçacığı sınıfını genişleten bir sınıf tarafından geçersiz kılınabilir.
katılmak()	join() yönteminin çağrıldığı iş parçacığı sonlandırılana kadar diğer kodun yürütülmesini engeller.

Arka Plan Hikayesi: Konu Sınıfı

İş parçacığı modülünü kullanarak çok iş parçacıklı programları kodlamaya başlamadan önce, Thread sınıfını anlamak çok önemlidir. İş parçacığı sınıfı, Python'da bir iş parçacığının şablonunu ve işlemlerini tanımlayan birincil sınıftır.

Çok iş parçacıklı bir python uygulaması oluşturmanın en yaygın yolu, Thread sınıfını genişleten ve run() yöntemini geçersiz kılan bir sınıf bildirmektir.

Thread sınıfı özetle ayrı bir kod dizisinde çalışan bir kod dizisini ifade eder. iplik kontrol

Yani, çok iş parçacıklı bir uygulama yazarken şunları yapacaksınız:

1. Thread sınıfını genişleten bir sınıf tanımlayın
2. Geçersiz kıl __init__ inşaatçı
3. Geçersiz kıl Çalıştırmak() yöntem

Bir iş parçacığı nesnesi oluşturulduktan sonra, Başlat() Bu aktivitenin yürütülmesine başlamak için yöntem kullanılabilir ve katılmak() yöntemi, mevcut etkinlik bitene kadar diğer tüm kodları engellemek için kullanılabilir.

Şimdi önceki örneğimizi uygulamak için iş parçacığı modülünü kullanmayı deneyelim. Tekrar, ateşini yak IDLE ve aşağıdakileri yazın:

import time
import threading

class threadtester (threading.Thread):
    def __init__(self, id, name, i):
       threading.Thread.__init__(self)
       self.id = id
       self.name = name
       self.i = i
       
    def run(self):
       thread_test(self.name, self.i, 5)
       print ("%s has finished execution " %self.name)

def thread_test(name, wait, i):

    while i:
       time.sleep(wait)
       print ("Running %s \n" %name)
       i = i - 1

if __name__=="__main__":
    thread1 = threadtester(1, "First Thread", 1)
    thread2 = threadtester(2, "Second Thread", 2)
    thread3 = threadtester(3, "Third Thread", 3)

    thread1.start()
    thread2.start()
    thread3.start()

    thread1.join()
    thread2.join()
    thread3.join()

Yukarıdaki kodu çalıştırdığınızda çıktı bu olacaktır:

KOD AÇIKLAMA

1. Bu kısım önceki örneğimizle aynıdır. Burada, yürütme ve gecikmeleri işlemek için kullanılan zaman ve iş parçacığı modülünü içe aktarırsınız. Python İş Parçacığı.
2. Bu bitte, threadtester adında, miras alan veya genişleten bir sınıf yaratıyorsunuz. Konu iş parçacığı modülünün sınıfı. Bu, python'da iş parçacığı oluşturmanın en yaygın yollarından biridir. Ancak, yalnızca yapıcıyı ve Çalıştırmak() uygulamanızda yöntem. Yukarıdaki kod örneğinde görebileceğiniz gibi, __init__ yöntem (yapıcı) geçersiz kılındı. Benzer şekilde, şunu da geçersiz kıldınız: Çalıştırmak() yöntem. Bir iş parçacığının içinde çalıştırmak istediğiniz kodu içerir. Bu örnekte thread_test() fonksiyonunu çağırdınız.
3. Bu, değerini alan thread_test() yöntemidir. i bağımsız değişken olarak, her yinelemede onu 1 azaltır ve i 0 olana kadar kodun geri kalanında döngü yapar. Her yinelemede, o anda yürütülen iş parçacığının adını yazdırır ve bekleme saniyeleri boyunca uyur (bu da bir bağımsız değişken olarak alınır) ).
4. thread1 = threadtester(1, “First Thread”, 1) Burada bir thread oluşturuyoruz ve __init__'de bildirdiğimiz üç parametreyi geçiyoruz. İlk parametre iş parçacığının kimliği, ikinci parametre iş parçacığının adı ve üçüncü parametre ise while döngüsünün kaç kez çalışması gerektiğini belirleyen sayaçtır.
5. thread2.start()T start yöntemi bir iş parçacığının yürütülmesini başlatmak için kullanılır. Dahili olarak start() işlevi, sınıfınızın run() yöntemini çağırır.
6. thread3.join() join() yöntemi diğer kodun yürütülmesini engeller ve çağrıldığı iş parçacığının tamamlanmasını bekler.

Bildiğiniz gibi, aynı işlemdeki iş parçacıkları o işlemin belleğine ve verilerine erişebilir. Sonuç olarak, birden fazla iş parçacığı aynı anda verileri değiştirmeye veya erişmeye çalışırsa, hatalar ortaya çıkabilir.

Bir sonraki bölümde, iş parçacıklarının mevcut erişim işlemlerini kontrol etmeden verilere ve kritik bölüme eriştiğinde ortaya çıkabilecek farklı komplikasyon türlerini göreceksiniz.

Kilitlenmeler ve Yarış koşulları

Kilitlenmeler ve yarış koşulları hakkında bilgi edinmeden önce, eşzamanlı programlamayla ilgili birkaç temel tanımı anlamak faydalı olacaktır:

• Kritik BölümPaylaşılan değişkenlere erişen veya onları değiştiren ve atomik bir işlem olarak gerçekleştirilmesi gereken bir kod parçasıdır.
• Bağlam DeğiştirmeBir CPU'nun, bir görevden diğerine geçmeden önce bir iş parçacığının durumunu depolamak ve daha sonra aynı noktadan devam edilebilmesini sağlamak için uyguladığı işlemdir.

kilitlenmeler

kilitlenmeler Geliştiricilerin Python'da eşzamanlı/çok iş parçacıklı uygulamalar yazarken karşılaştıkları en çok korkulan sorundur. Kilitlenmeleri anlamak için en iyi yol, klasik bilgisayar bilimi örnek problemi olarak bilinen Gastronomi Philosophers Sorunu.

Yemek felsefecileri için problem ifadesi şu şekildedir:

Beş filozof, şekilde görüldüğü gibi, beş tabak spagetti (bir makarna türü) ve beş çatalla yuvarlak bir masanın etrafında oturuyorlar.

Bir filozofun herhangi bir anda ya yemek yediği ya da düşündüğü anlaşılıyor.

Dahası, bir filozof spagettiyi yiyebilmek için önce yanındaki iki çatalı (yani sol ve sağ çatalı) almak zorundadır. Kilitlenme sorunu, beş filozofun da sağ çatallarını aynı anda almasıyla ortaya çıkar.

Filozofların her birinin bir çatalı olduğundan, hepsi diğerlerinin çatallarını bırakmasını bekleyeceklerdir. Sonuç olarak, hiçbiri spagetti yiyemeyecektir.

Benzer şekilde, eşzamanlı bir sistemde, farklı iş parçacıkları veya süreçler (filozoflar) aynı anda paylaşılan sistem kaynaklarını (çatallar) edinmeye çalıştığında bir çıkmaz meydana gelir. Sonuç olarak, süreçlerin hiçbiri başka bir süreç tarafından tutulan başka bir kaynağı bekledikleri için yürütülme şansı elde edemez.

Yarış koşulları

Yarış durumu, bir sistem iki veya daha fazla işlemi aynı anda gerçekleştirdiğinde oluşan istenmeyen bir program durumudur. Örneğin, bu basit for döngüsünü ele alalım:

i=0; # a global variable
for x in range(100):
    print(i)
    i+=1;

eğer yaratırsan n Bu kodu aynı anda çalıştıran iş parçacığı sayısı çok fazla olduğundan, program yürütmeyi bitirdiğinde i'nin (iş parçacıkları tarafından paylaşılan) değerini belirleyemezsiniz. Bunun nedeni, gerçek bir çok iş parçacıklı ortamda iş parçacıklarının üst üste gelebilmesi ve bir iş parçacığı tarafından alınan ve değiştirilen i değerinin, başka bir iş parçacığının ona erişmesi sırasında değişebilmesidir.

Bunlar, çok iş parçacıklı veya dağıtılmış bir python uygulamasında ortaya çıkabilecek iki ana sorun sınıfıdır. Bir sonraki bölümde, iş parçacıklarını senkronize ederek bu sorunun nasıl üstesinden geleceğinizi öğreneceksiniz.

Synckonuları hronize etmek

Yarış koşulları, çıkmazlar ve diğer iş parçacığı tabanlı sorunlarla başa çıkmak için iş parçacığı modülü şunları sağlar: kilitlemek nesne. Fikir, bir iş parçacığının belirli bir kaynağa erişmek istemesi durumunda, o kaynak için bir kilit edinmesidir. Bir iş parçacığı belirli bir kaynağı kilitlediğinde, kilit serbest bırakılana kadar başka hiçbir iş parçacığı ona erişemez. Sonuç olarak, kaynaktaki değişiklikler atomik olacak ve yarış koşulları önlenecektir.

Bir kilit, tarafından uygulanan düşük seviyeli bir senkronizasyon ilkelidir. __Konu modülü. Herhangi bir zamanda bir kilit 2 durumdan birinde olabilir: kilitli or kilitsiz. İki yöntemi destekler:

1. elde etmek()Kilit durumunun kilidi açıldığında, gain() yönteminin çağrılması durumu kilitli olarak değiştirecek ve geri dönecektir. Ancak durum kilitliyse, gain() çağrısı, Release() yöntemi başka bir iş parçacığı tarafından çağrılana kadar engellenir.
2. serbest bırakmak()Release() yöntemi, durumu kilitsiz olarak ayarlamak, yani bir kilidi serbest bırakmak için kullanılır. Kilidi alan herhangi bir iş parçacığı tarafından çağrılabilir.

Uygulamalarınızda kilit kullanımına ilişkin bir örneği burada bulabilirsiniz. Ateşleyin IDLE ve aşağıdakileri yazın:

import threading
lock = threading.Lock()

def first_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the first funcion')
        lock.release()

def second_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the second funcion')
        lock.release()

if __name__=="__main__":
    thread_one = threading.Thread(target=first_function)
    thread_two = threading.Thread(target=second_function)

    thread_one.start()
    thread_two.start()

    thread_one.join()
    thread_two.join()

Şimdi F5'e basın. Bunun gibi bir çıktı görmelisiniz:

KOD AÇIKLAMA

1. Burada sadece çağrı yaparak yeni bir kilit oluşturuyorsunuz. iş parçacığı.Lock() fabrika işlevi. Dahili olarak Lock(), platform tarafından sağlanan en etkili somut Lock sınıfının bir örneğini döndürür.
2. İlk ifadede, gain() yöntemini çağırarak kilidi elde edersiniz. Kilit verildiğinde yazdırırsınız “kilit alındı” konsola. İş parçacığının çalışmasını istediğiniz tüm kodun yürütmesi bittiğinde, Release() yöntemini çağırarak kilidi serbest bırakırsınız.

Teori güzel ama kilidin gerçekten işe yaradığını nereden biliyorsun? Çıktıya bakarsanız, print ifadelerinin her birinin bir seferde tam olarak bir satır yazdırdığını göreceksiniz. Daha önceki bir örnekte, birden fazla iş parçacığının aynı anda print() yöntemine erişmesi nedeniyle print çıktılarının gelişigüzel olduğunu hatırlayın. Burada yazdırma işlevi yalnızca kilit alındıktan sonra çağrılır. Böylece çıktılar teker teker ve satır satır görüntülenir.

Kilitlerin dışında, Python ayrıca aşağıda listelenen iş parçacığı senkronizasyonunu yönetmek için bazı diğer mekanizmaları da destekler:

1. RKilitler
2. Semaphores
3. Koşullar
4. Etkinlikler ve
5. Bariyerler

Küresel Tercüman Kilidi (ve bununla nasıl başa çıkılacağı)

Python'un GIL'inin detaylarına girmeden önce, gelecek bölümü anlamanızda faydalı olacak birkaç terimi tanımlayalım:

1. CPU'ya bağlı kod: Bu, doğrudan CPU tarafından yürütülecek herhangi bir kod parçasını ifade eder.
2. G/Ç bağlantılı kod: Bu, işletim sistemi aracılığıyla dosya sistemine erişen herhangi bir kod olabilir
3. CPython: bu referanstır uygulama of Python ve C ile yazılmış yorumlayıcı olarak tanımlanabilir ve Python (programlama dili).

Belirli bir zamanda yalnızca bir iş parçacığının belirli bir kaynağa erişebildiğinden emin olmak için kilit kullanılabilir.

özelliklerinden biri Python her yorumlayıcı işleminde global bir kilit kullanmasıdır, bu da her işlemin Python yorumlayıcısını bir kaynak olarak ele alması anlamına gelir.

Örneğin, hem CPU hem de 'G/Ç' işlemlerini gerçekleştirmek için iki iş parçacığı kullanan bir python programı yazdığınızı varsayalım. Bu programı çalıştırdığınızda şöyle olur:

1. Python yorumlayıcısı yeni bir süreç yaratır ve iş parçacıklarını oluşturur
2. İş parçacığı-1 çalışmaya başladığında ilk önce GIL'yi alacak ve kilitleyecektir.
3. Eğer iş parçacığı-2 şimdi yürütülmek istiyorsa, başka bir işlemci boş olsa bile GIL'in serbest bırakılmasını beklemek zorunda kalacak.
4. Şimdi iş parçacığı-1'in bir G/Ç işlemini beklediğini varsayalım. Şu anda GIL'i serbest bırakacak ve iş parçacığı-2 onu alacak.
5. G/Ç işlemlerini tamamladıktan sonra, eğer iş parçacığı-1 şimdi yürütmek istiyorsa, yine GIL'in iş parçacığı-2 tarafından serbest bırakılmasını beklemek zorunda kalacak.

Bu nedenle, herhangi bir zamanda yorumlayıcıya yalnızca bir iş parçacığı erişebilir; bu, belirli bir zamanda python kodunu çalıştıran yalnızca bir iş parçacığının olacağı anlamına gelir.

Tek çekirdekli bir işlemcide bu sorun değildir çünkü iş parçacıklarını işlemek için zaman dilimleme (bu eğitimin ilk bölümüne bakın) kullanılacaktır. Bununla birlikte, çok çekirdekli işlemciler söz konusu olduğunda, birden fazla iş parçacığı üzerinde yürütülen CPU'ya bağlı bir işlevin, aslında mevcut tüm çekirdekleri aynı anda kullanmayacağından programın verimliliği üzerinde önemli bir etkisi olacaktır.

GIL'e neden ihtiyaç duyuldu?

CPython Çöp toplayıcı, referans sayımı olarak bilinen etkili bir bellek yönetim tekniği kullanır. İşte nasıl çalıştığı: Python'daki her nesnenin, yeni bir değişken adına atandığında veya bir kapsayıcıya (örneğin, tuple'lar, listeler, vb.) eklendiğinde artan bir referans sayısı vardır. Benzer şekilde, referans kapsam dışına çıktığında veya del ifadesi çağrıldığında referans sayısı azalır. Bir nesnenin referans sayısı 0'a ulaştığında, çöp toplanır ve ayrılan bellek serbest bırakılır.

Ancak sorun, referans sayısı değişkeninin diğer tüm global değişkenler gibi yarış koşullarına yatkın olmasıdır. Bu sorunu çözmek için, Python geliştiricileri global yorumlayıcı kilidini kullanmaya karar verdiler. Diğer seçenek, her nesneye bir kilit eklemekti; bu da çıkmazlara ve acquire() ve release() çağrılarından kaynaklanan ek yükün artmasına neden olurdu.

Bu nedenle GIL, ağır CPU bağlantılı işlemleri çalıştıran çok iş parçacıklı python programları için önemli bir kısıtlamadır (bunları etkili bir şekilde tek iş parçacıklı hale getirir). Uygulamanızda birden fazla CPU çekirdeği kullanmak istiyorsanız çoklu işlem modül yerine.

ÖZET

• Python çoklu iş parçacığı için 2 modülü destekler:
  1. __Konu modül: İş parçacığı için düşük düzeyli bir uygulama sağlar ve artık kullanılmamaktadır.
  2. iş parçacığı modülü: Çoklu iş parçacığı için üst düzey bir uygulama sağlar ve mevcut standarttır.
• İş parçacığı modülünü kullanarak bir iş parçacığı oluşturmak için aşağıdakileri yapmalısınız:
  1. genişleten bir sınıf oluşturun. Konu sınıf.
  2. Yapıcısını (__init__) geçersiz kılın.
  3. Geçersiz kıl Çalıştırmak() yöntemi.
  4. Bu sınıftan bir nesne oluşturun.
• Bir iş parçacığı çağrılarak yürütülebilir Başlat() yöntemi.
• The katılmak() yöntemi, bu iş parçacığı (birleştirmenin çağrıldığı iş parçacığı) yürütmeyi tamamlayana kadar diğer iş parçacıklarını engellemek için kullanılabilir.
• Birden fazla iş parçacığı aynı anda paylaşılan bir kaynağa eriştiğinde veya bunları değiştirdiğinde bir yarış durumu oluşur.
• Şununla önlenebilir: Synckonuları kronize etmek.
• Python iş parçacıklarını senkronize etmenin 6 yolunu destekler:
  1. Kilitler
  2. RKilitler
  3. Semaphores
  4. Koşullar
  5. Etkinlikler ve
  6. Bariyerler
• Kilitler yalnızca kilidi alan belirli bir iş parçacığının kritik bölüme girmesine izin verir.
• Bir Kilidin 2 temel yöntemi vardır:
  1. elde etmek(): Kilit durumunu şu şekilde ayarlar: kilitli. Kilitli bir nesne üzerinden çağrılırsa kaynak serbest kalana kadar bloke olur.
  2. serbest bırakmak(): Kilit durumunu şu şekilde ayarlar: kilitsiz ve geri döner. Kilidi açılmış bir nesnede çağrılırsa false değerini döndürür.
• Küresel tercüman kilidi yalnızca 1 C'nin kullanılabileceği bir mekanizmadır.Python tercüman işlemi aynı anda yürütülebilir.
• C'nin referans sayma işlevini kolaylaştırmak için kullanıldıPythonS'nin çöp toplayıcısı.
• Yapmak için Python Yoğun CPU kullanımı gerektiren uygulamalarda çoklu işlem modülünü kullanmalısınız.