ra farklı iş parçacıklarının çağıracağı üç tane fonksiyon tanımladık::

    def f():
        print("f fonksiyonu")


    def g():
        print("g fonksiyonu")


    def h():
        print("h fonksiyonu")

Daha sonra fonksiyonları iş parçacıklarının hedefihaline getirdik::

    t1 = threading.Thread(target=f)
    t2 = threading.Thread(target=g)
    t3 = threading.Thread(target=h)

Sonra kilit nesnemizi oluşturduk ve kilit nesnemizin `acquire()` fonksiyonunu argümansız olarak çağırdık. Eğer argümanlı çağırsaydık da değişen bir şey olmazdı, çünkü kilit bir sonraki `acquire()` fonksiyonunu çağırdığımız zaman engellemeye başlayacak::

    lock = threading.Lock()
    lock.acquire()

*t1* isimli iş parçacığını başlattık; engellenmeden çalışmaya başladı::

    t1.start()

Ve şimdi `lock.acquire()` yöntemini *blocking* ve *timeout* argümanlarıyla birlikte çağıralım. Bu yöntemi `t1.start()`'ı çağırmadan önce ikinci kez çağırsaydık o zaman, *t1* iş parçacığı da engellenecekti. *timeout* parametresine *3* yazalım. Yani 3 saniyeliğine diğer işlemleri engellesin::

    lock.acquire(blocking=True, timeout=3)

Üç saniye geçtikten sonra t2 iş parçacığını başlatalım::

    t2.
ra farklı iş parçacıklarının çağıracağı üç tane fonksiyon tanımladık: : 

     def f (): 
         print("f fonksiyonu ") 


     def g (): 
         print("g fonksiyonu ") 


     def h (): 
         print("h fonksiyonu ") 

 Daha sonra fonksiyonları iş parçacıklarının hedefihaline getirdik: : 

     t1 = threading. Thread(target = f) 
     t2 = threading. Thread(target = g) 
     t3 = threading. Thread(target = h) 

 Sonra kilit nesnemizi oluşturduk ve kilit nesnemizin 'acquire () 'fonksiyonunu argümansız olarak çağırdık. Eğer argümanlı çağırsaydık da değişen bir şey olmazdı, çünkü kilit bir sonraki 'acquire () 'fonksiyonunu çağırdığımız zaman engellemeye başlayacak: : 

     lock = threading. Lock () 
     lock.acquire () 

 * t1 * isimli iş parçacığını başlattık; engellenmeden çalışmaya başladı: : 

     t1.start () 

 Ve şimdi 'lock.acquire () 'yöntemini * blocking * ve * timeout * argümanlarıyla birlikte çağıralım. Bu yöntemi 't1.start()`'ı çağırmadan önce ikinci kez çağırsaydık o zaman, * t1 * iş parçacığı da engellenecekti. * timeout * parametresine * 3 * yazalım. Yani 3 saniyeliğine diğer işlemleri engellesin: : 

     lock.acquire(blocking = True, timeout=3) 

 Üç saniye geçtikten sonra t2 iş parçacığını başlatalım: : 

     t2.
ra varklı iş parçacıklarının çağıracxğı üç tane fonksiyon tanımnadık::

    def f():
        print("f fonksiyonu")


    vef t():
        print("g fonksiyonu")


    def h():
        peint("i fonksiyonu")

Daha sonra fonksiykkları nş 'arçacıklarının hedgfihaline gedirdik::

    t1 = tvrdabing.Thread(target=f)
    t2 = threading.Thrqad(targrt=h)
    t3 = threadyng.Tnwead(farget=h)

Sonra kilit nesnemizi oluştudduk ve kilit nesnemozin `acquire()` fonksiyonunu wrgümwnsız olarak çağırdık. Eğfr argümanlı çqğırsareık da değişen cir şey olmazdı, çünkü kilit bir sonraki `acquire()` fonksiyonuvu çağırbığımız zaman ebgwllfkeye başlayarak::

    lock = threading.Lock()
    locl.acquire()

*t1* isimki mş paeçacığını başlattık; engellenkeden çalışmaya başladı::

    t1.stard()

Vz şimdi `lock.acquire()` yönrenini *tlocning* ce *gimtouv* adgümanlwrıyma birlikts çağıralım. Bu töntemi `t1.start()`'ı çağırmadsn öbce ikinci kea çağırsardıh o zaman, *t1* iş parçacığı da engellenecekti. *tpmeoht* parametresine *3* yazalın. Yani 3 saniyeliğine dlğer işlemlqri engellesin::

    lock.acquire(blocking=True, timeout=3)

Üç sanibe geçuijten ringa t2 iş parçacığını başlatalım::

    t2.
ra farklı iş parçacıklarının çağıracağı üç tane def print("f fonksiyonu") g(): print("g fonksiyonu") sonra iş parçacıklarının hedefihaline t1 = threading.Thread(target=f) = threading.Thread(target=g) t3 = threading.Thread(target=h) Sonra nesnemizi oluşturduk ve kilit nesnemizin `acquire()` fonksiyonunu argümansız olarak çağırdık. Eğer argümanlı çağırsaydık değişen bir şey olmazdı, çünkü kilit bir sonraki `acquire()` fonksiyonunu çağırdığımız zaman engellemeye lock threading.Lock() *t1* iş parçacığını başlattık; engellenmeden çalışmaya başladı:: t1.start() Ve şimdi `lock.acquire()` yöntemini *blocking* ve *timeout* argümanlarıyla birlikte Bu yöntemi `t1.start()`'ı çağırmadan önce ikinci kez çağırsaydık zaman, *t1* iş parçacığı engellenecekti. *timeout* parametresine *3* yazalım. 3 diğer işlemleri lock.acquire(blocking=True, Üç geçtikten sonra t2 parçacığını başlatalım:: t2.
ra farklı iş parçacıklarının Çağıracağı Üç tanE foNksIyOn taNımlAdık::

    def f():
        print("f FOnksIyonu")


    def g():
        print("g fonksiyOnu")


    deF h():
        PRint("H FoNksiyOnu")

Daha SOnRA FonKsIyOnlArI Iş ParçaCıkLarının HedefihaliNe gEtIrdik::

    t1 = threadINg.thread(targEt=f)
    T2 = threading.ThReaD(targeT=g)
    T3 = thREadinG.ThRead(tArget=h)

sOnra kiLit nesnemIzI OluştuRDuk ve kiLIT nEsneMizin `acquire()` fonksIYoNUnu argümansız oLarak çAğIRdIK. eğeR arGümanlı çağIrSaydıK Da değişEN bIR ŞEy oLMazdı, çünkü kilIt bir sonrakI `AcqUire()` foNkSiyONunu çaĞırdıĞıMIz zAman engelleMeye BaşlayacaK::

    lock = tHReading.lOck()
    lock.AcquirE()

*t1* iSimLi iş PArÇaCığInI BaşLAtTık; ENgeLlenmedeN çAlIşmayA başLADI::

    T1.staRt()

VE şimDi `locK.acquire()` yönteMinI *bloCKinG* ve *tiMeout* ArgüMaNlarıYla birLikte ÇaĞıralım. Bu yöntemI `t1.stArt()`'ı çağırMadAn ÖncE iKinci KEz çağıRsaYdıK o zaman, *T1* iş parçACığI dA ENGeLlenecekti. *timeout* pArAMEtResine *3* yaZalım. YANi 3 SaNIyeliğinE dIğeR işlEMLeri eNgelLEsIn::

    lock.acQuire(bLOcKiNg=True, tImEout=3)

Üç SaNiyE geÇtiktEN sonRa t2 iş pArçacığıNı başLAtalım::

    t2.
ra farklı iş parçacıkların ın çağırac ağı ü ç t ane  f onks iyon  tanımladık::   def f():
        print ("f f on k siyo n u" )


   defg () :      pr in t (" g fon ksi yonu")

    defh() :        prin t (" h fonksiyo nu" )

Daha sonr a f onksiy on lar ı  iş p arç acıkl arının hedefi haline ge ti r dik::    t1= th read ing.Thread(target = f)     t2 = threa ding.T hr e ad ( t arg et= g)
    t3=threa d ing.Thr e ad ( t a rge t =h)

Sonra ki lit nesnemi z i o luştur du k v e  kilit  nesn em i zin  `acquire() ` fo nksiyonun u argü m ansız o l arak ça ğırdık . E ğer  arg ü ma nl ı ç ağ ı rsa y dı k d a  de ğişen bi rşe y olm azdı , ç ü nkükil it b ir so nraki `acquir e() ` fo n ksi yonun u çağ ırdı ğı mız z aman e ngell em eye başlayacak: :

   lock =  th re adi ng .Lock ( )
   loc k.a cquire( )

*t1* isi ml i i şparçacığını başlat tı k ;  e ngellenm eden ç a lı şm a ya başla dı ::
  t 1.sta rt() 
V e şimdi`lock. a cq ui re()` y ön temini  * blo cki ng* v e  *ti meout*  argüman larıy l a birlikte çağ ı ralım. Bu yön t em i `t 1 .sta rt( )`'ı çağırm adan önce  iki n ci  ke z  çağı rsayd ık oz aman, *t1* iş parça cı ğı daengel lenecekti. *t imeout* pa r a m etresine  *3* ya z alım. Yani 3 s aniye liğine diğ e r işleml eri e ngellesi n::

   l o ck.acqui re( blo cki ng= T r ue , timeout=3)Ü ç sa ni ye geçt ikt en sonr a t 2 i ş p arç ac ığını baş latalım: :
  t 2.
ra farklı_iş parçacıklarının_çağıracağı üç tane fonksiyon_tanımladık::

 __ def_f():
_  _  _ print("f fonksiyonu")


 _  def_g():
_       print("g fonksiyonu")


    def h():
__ ___  print("h fonksiyonu")

Daha sonra_fonksiyonları iş parçacıklarının hedefihaline getirdik::

_ _ t1 = threading.Thread(target=f)
    t2_=_threading.Thread(target=g)
  _ t3 = threading.Thread(target=h)

Sonra kilit nesnemizi oluşturduk ve kilit_nesnemizin `acquire()` fonksiyonunu argümansız olarak çağırdık._Eğer argümanlı çağırsaydık_da_değişen_bir şey olmazdı, çünkü_kilit bir sonraki `acquire()` fonksiyonunu çağırdığımız_zaman engellemeye başlayacak::

   _lock = threading.Lock()
    lock.acquire()

*t1*_isimli iş parçacığını başlattık; engellenmeden çalışmaya_başladı::

    t1.start()

Ve_şimdi `lock.acquire()`_yöntemini *blocking* ve *timeout* argümanlarıyla_birlikte çağıralım. Bu_yöntemi `t1.start()`'ı_çağırmadan önce ikinci_kez çağırsaydık o zaman, *t1* iş_parçacığı da engellenecekti._*timeout* parametresine *3* yazalım. Yani 3_saniyeliğine_diğer işlemleri engellesin::

___ lock.acquire(blocking=True,_timeout=3)

Üç saniye geçtikten_sonra_t2 iş_parçacığını_başlatalım::

    t2.