Konuların Uygulanması

Bu bölümde, iş parçacıklarının Python'da nasıl uygulanacağını öğreneceğiz.

Thread Uygulaması için Python Modülü

Python iş parçacıkları bazen hafif işlemler olarak adlandırılır çünkü iş parçacıkları işlemlerden çok daha az bellek kullanır. İş parçacığı, aynı anda birden fazla görevi gerçekleştirmeye izin verir. Python'da, bir programda iş parçacıkları uygulayan aşağıdaki iki modüle sahibiz:

<_thread>module
<threading>module

Bu iki modül arasındaki temel fark şudur: <_thread> modül bir iş parçacığını bir işlev olarak ele alırken, <threading>modül her evreyi bir nesne olarak ele alır ve nesneye yönelik bir şekilde uygular. Dahası,<_thread>modül, düşük seviyeli diş açmada etkilidir ve <threading> modül.

<_thread> modülü

Python'un önceki sürümünde, <thread>modül, ancak oldukça uzun bir süredir "kullanımdan kaldırıldı" olarak kabul edildi. Kullanıcıların şunları kullanmaları teşvik edilmiştir:<threading>modül yerine. Bu nedenle, Python 3'te "thread" modülü artık mevcut değildir. "Olarak yeniden adlandırıldı<_thread>"Python3'teki geriye dönük uyumsuzluklar için.

Yardımıyla yeni iş parçacığı oluşturmak <_thread> modülü aramalıyız start_new_threadyöntemi. Bu yöntemin çalışması, aşağıdaki sözdizimi yardımıyla anlaşılabilir -

_thread.start_new_thread ( function, args[, kwargs] )

Burada -

args bir dizi argümandır
kwargs isteğe bağlı bir anahtar kelime argümanları sözlüğüdür

Bir argüman iletmeden işlevi çağırmak istiyorsak, o zaman içinde boş bir argüman demeti kullanmamız gerekir. args.

Bu yöntem çağrısı hemen geri döner, çocuk evre başlar ve işlevi, varsa, args'ın geçirilen listesiyle çağırır. İş parçacığı, işlev döndüğünde sona erer.

Misal

Aşağıda, kullanarak yeni iş parçacığı oluşturmaya bir örnek verilmiştir. <_thread>modül. Burada start_new_thread () yöntemini kullanıyoruz.

import _thread
import time

def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print ("%s: %s" % ( threadName, time.ctime(time.time()) ))

try:
   _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print ("Error: unable to start thread")
while 1:
   pass

Çıktı

Aşağıdaki çıktı, yeni konuların neslini anlamamıza yardımcı olacaktır. <_thread> modül.

Thread-1: Mon Apr 23 10:03:33 2018
Thread-2: Mon Apr 23 10:03:35 2018
Thread-1: Mon Apr 23 10:03:35 2018
Thread-1: Mon Apr 23 10:03:37 2018
Thread-2: Mon Apr 23 10:03:39 2018
Thread-1: Mon Apr 23 10:03:39 2018
Thread-1: Mon Apr 23 10:03:41 2018
Thread-2: Mon Apr 23 10:03:43 2018
Thread-2: Mon Apr 23 10:03:47 2018
Thread-2: Mon Apr 23 10:03:51 2018

<iş parçacığı> modülü

<threading>modülü nesneye yönelik bir şekilde uygular ve her evreyi bir nesne olarak ele alır. Bu nedenle, iş parçacıkları için <_thread> modülünden çok daha güçlü, üst düzey destek sağlar. Bu modül Python 2.4'e dahildir.

<threading> modülündeki ek yöntemler

<threading> modülün tüm yöntemlerini içerir <_thread>modül ancak ek yöntemler de sağlar. Ek yöntemler aşağıdaki gibidir -

threading.activeCount() - Bu yöntem, aktif olan iş parçacığı nesnelerinin sayısını döndürür
threading.currentThread() - Bu yöntem, çağıranın iş parçacığı kontrolündeki iş parçacığı nesnelerinin sayısını döndürür.
threading.enumerate() - Bu yöntem, şu anda aktif olan tüm iş parçacığı nesnelerinin bir listesini döndürür.

Diş açmayı uygulamak için, <threading> modülde Thread Aşağıdaki yöntemleri sağlayan sınıf -

run() - run () yöntemi, bir iş parçacığının giriş noktasıdır.
start() - start () yöntemi, çalıştırma yöntemini çağırarak bir iş parçacığı başlatır.
join([time]) - join (), iş parçacıklarının sona ermesini bekler.
isAlive() - isAlive () yöntemi, bir iş parçacığının hala yürütülmekte olup olmadığını kontrol eder.
getName() - getName () yöntemi bir iş parçacığının adını döndürür.
setName() - setName () yöntemi bir iş parçacığının adını belirler.

<threading> modülünü kullanarak iş parçacığı nasıl oluşturulur?

Bu bölümde, kullanarak iş parçacığı oluşturmayı öğreneceğiz. <threading>modül. <threading> modülünü kullanarak yeni bir iş parçacığı oluşturmak için şu adımları izleyin -

Step 1 - Bu adımda, yeni bir alt sınıf tanımlamamız gerekiyor. Thread sınıf.
Step 2 - Daha sonra ek argümanlar eklemek için, __init__(self [,args]) yöntem.
Step 3 - Bu adımda, başlatıldığında iş parçacığının ne yapması gerektiğini uygulamak için run (self [, args]) yöntemini geçersiz kılmamız gerekir.

Şimdi, yenisini oluşturduktan sonra Thread alt sınıf, bunun bir örneğini oluşturabilir ve ardından yeni bir iş parçacığı başlatabiliriz. start()bu da sırayla run() yöntem.

Misal

Nasıl yeni bir iş parçacığı oluşturacağınızı öğrenmek için bu örneği düşünün. <threading> modül.

import threading
import time
exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print ("Starting " + self.name)
      print_time(self.name, self.counter, 5)
      print ("Exiting " + self.name)
def print_time(threadName, delay, counter):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print ("%s: %s" % (threadName, time.ctime(time.time())))
      counter -= 1

thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("Exiting Main Thread")
Starting Thread-1
Starting Thread-2

Çıktı

Şimdi, aşağıdaki çıktıyı düşünün -

Thread-1: Mon Apr 23 10:52:09 2018
Thread-1: Mon Apr 23 10:52:10 2018
Thread-2: Mon Apr 23 10:52:10 2018
Thread-1: Mon Apr 23 10:52:11 2018
Thread-1: Mon Apr 23 10:52:12 2018
Thread-2: Mon Apr 23 10:52:12 2018
Thread-1: Mon Apr 23 10:52:13 2018
Exiting Thread-1
Thread-2: Mon Apr 23 10:52:14 2018
Thread-2: Mon Apr 23 10:52:16 2018
Thread-2: Mon Apr 23 10:52:18 2018
Exiting Thread-2
Exiting Main Thread

Çeşitli Diş Durumları için Python Programı

Beş iş parçacığı durumu vardır - yeni, çalıştırılabilir, koşuyor, bekliyor ve ölü. Bu beşinden, esas olarak üç eyalete odaklanacağız - koşmak, beklemek ve ölmek. Bir iş parçacığı kaynaklarını çalışma durumunda alır, bekleme durumunda kaynakları bekler; Yürütülüyorsa ve ediniliyorsa kaynağın son serbest bırakılması ölü durumdaysa.

Start (), sleep () ve join () yöntemlerinin yardımıyla aşağıdaki Python programı, bir iş parçacığının sırasıyla çalışan, bekleme ve ölü duruma nasıl girildiğini gösterecektir.

Step 1 - Gerekli modülleri, <iş parçacığı> ve <zaman> içe aktarın

import threading
import time

Step 2 - Bir iş parçacığı oluştururken çağrılacak bir işlev tanımlayın.

def thread_states():
   print("Thread entered in running state")

Step 3 - İş parçacığımızı 2 saniye bekletmek için zaman modülünün sleep () yöntemini kullanıyoruz.

time.sleep(2)

Step 4 - Şimdi, yukarıda tanımlanan fonksiyonun argümanını alan T1 adında bir evre oluşturuyoruz.

T1 = threading.Thread(target=thread_states)

Step 5- Şimdi, start () işlevi yardımıyla iş parçacığımızı başlatabiliriz. Fonksiyonu tanımlarken tarafımızca belirlenen mesajı üretecektir.

T1.start()
Thread entered in running state

Step 6 - Artık, iş parçacığını çalıştırmayı bitirdikten sonra join () yöntemi ile öldürebiliriz.

T1.join()

Python'da iş parçacığı başlatmak

Python'da farklı yollarla yeni bir iş parçacığı başlatabiliriz ancak bunların en kolayı onu tek bir işlev olarak tanımlamaktır. Fonksiyonu tanımladıktan sonra, bunu yeni bir hedef olarak geçebiliriz.threading.Threadnesne vb. İşlevin nasıl çalıştığını anlamak için aşağıdaki Python kodunu çalıştırın -

import threading
import time
import random
def Thread_execution(i):
   print("Execution of Thread {} started\n".format(i))
   sleepTime = random.randint(1,4)
   time.sleep(sleepTime)
   print("Execution of Thread {} finished".format(i))
for i in range(4):
   thread = threading.Thread(target=Thread_execution, args=(i,))
   thread.start()
   print("Active Threads:" , threading.enumerate())

Çıktı

Execution of Thread 0 started
Active Threads:
   [<_MainThread(MainThread, started 6040)>,
      <HistorySavingThread(IPythonHistorySavingThread, started 5968)>,
      <Thread(Thread-3576, started 3932)>]

Execution of Thread 1 started
Active Threads:
   [<_MainThread(MainThread, started 6040)>,
      <HistorySavingThread(IPythonHistorySavingThread, started 5968)>,
      <Thread(Thread-3576, started 3932)>,
      <Thread(Thread-3577, started 3080)>]

Execution of Thread 2 started
Active Threads:
   [<_MainThread(MainThread, started 6040)>,
      <HistorySavingThread(IPythonHistorySavingThread, started 5968)>,
      <Thread(Thread-3576, started 3932)>,
      <Thread(Thread-3577, started 3080)>,
      <Thread(Thread-3578, started 2268)>]

Execution of Thread 3 started
Active Threads:
   [<_MainThread(MainThread, started 6040)>,
      <HistorySavingThread(IPythonHistorySavingThread, started 5968)>,
      <Thread(Thread-3576, started 3932)>,
      <Thread(Thread-3577, started 3080)>,
      <Thread(Thread-3578, started 2268)>,
      <Thread(Thread-3579, started 4520)>]
Execution of Thread 0 finished
Execution of Thread 1 finished
Execution of Thread 2 finished
Execution of Thread 3 finished

Python'da Daemon konuları

Python'da daemon evrelerini uygulamadan önce, arka plan süreçleri ve kullanımları hakkında bilgi sahibi olmamız gerekir. Bilgi işlem açısından daemon, veri gönderme, dosya transferleri vb. Gibi çeşitli hizmetlere yönelik talepleri işleyen bir arka plan işlemidir. Artık gerekli değilse, uykuda olacaktır. Aynı görev, arka plan programı olmayan iş parçacıkları yardımıyla da yapılabilir. Ancak, bu durumda, ana iş parçacığı, arka plan programı olmayan evreleri manuel olarak takip etmelidir. Öte yandan, eğer arka plan iş parçacığı kullanıyorsak, ana iş parçacığı bunu tamamen unutabilir ve ana iş parçacığı çıktığında ortadan kalkar. Daemon iş parçacıklarıyla ilgili bir başka önemli nokta da, onları yalnızca, tamamlanmazsa veya arada öldürülürse bizi etkilemeyecek gerekli olmayan görevler için kullanmayı seçebileceğimizdir. Aşağıda daemon iş parçacıklarının python'da uygulanması -

import threading
import time

def nondaemonThread():
   print("starting my thread")
   time.sleep(8)
   print("ending my thread")
def daemonThread():
   while True:
   print("Hello")
   time.sleep(2)
if __name__ == '__main__':
   nondaemonThread = threading.Thread(target = nondaemonThread)
   daemonThread = threading.Thread(target = daemonThread)
   daemonThread.setDaemon(True)
   daemonThread.start()
   nondaemonThread.start()

Yukarıdaki kodda iki işlev vardır: >nondaemonThread() ve >daemonThread(). İlk işlev durumunu yazdırır ve 8 saniye sonra uyurken deamonThread () işlevi her 2 saniyede bir süresiz olarak Hello yazdırır. Aşağıdaki çıktı yardımıyla nondaemon ve daemon iş parçacıkları arasındaki farkı anlayabiliriz -

Hello

starting my thread
Hello
Hello
Hello
Hello
ending my thread
Hello
Hello
Hello
Hello
Hello