آموزش پایتون - چندنخی

در پایتون، چندنخی (Multithreading) به شما امکان می‌دهد تا چند نخ (Thread) را به‌طور هم‌زمان در قالب یک پروسه واحد اجرا کنید که به آن موازی‌سازی مبتنی بر نخ نیز گفته می‌شود. این بدین معناست که یک برنامه می‌تواند چندین کار را به‌طور هم‌زمان انجام دهد و کارایی و پاسخ‌گویی خود را بهبود بخشد.

چندنخی در پایتون به‌ویژه برای عملیات‌های متعدد وابسته به ورودی/خروجی (I/O-bound) مفید است، نه برای کارهایی که نیاز به محاسبات سنگین دارند.

به‌طور کلی، یک برنامه کامپیوتری دستورالعمل‌ها را به‌صورت متوالی از ابتدا تا انتها اجرا می‌کند. در حالی که چندنخی، وظیفه اصلی را به بیش از یک زیر-وظیفه تقسیم کرده و آن‌ها را به‌صورت هم‌پوشان اجرا می‌نماید.

مقایسه با پروسه‌ها (Processes)

یک سیستم‌عامل قادر است چندین پروسه را به‌طور هم‌زمان مدیریت کند. سیستم‌عامل یک فضای حافظه مجزا به هر پروسه اختصاص می‌دهد تا یک پروسه نتواند به فضای پروسه دیگر دسترسی داشته باشد یا در آن چیزی بنویسد.

از سوی دیگر، یک نخ را می‌توان یک زیر-پروسه سبک در یک برنامه واحد دانسته که فضای حافظه اختصاص‌یافته به آن برنامه را به اشتراک می‌گذارد و ارتباط و اشتراک‌گذاری داده‌ها را آسان‌تر می‌کند. از آنجا که نخ‌ها سبک هستند و به حافظه زیادی نیاز ندارند، کم‌هزینه‌تر از پروسه‌ها هستند.

multithreading

یک پروسه همیشه با یک نخ واحد (نخ اصلی یا main thread) آغاز می‌شود. در صورت نیاز، می‌توان یک نخ جدید را شروع کرد و زیر-وظیفه‌ای را به آن واگذار نمود. اکنون این دو نخ به‌صورت هم‌پوشان کار می‌کنند. زمانی که وظیفه محول‌شده به نخ ثانویه به پایان رسید، با نخ اصلی ادغام می‌شود.

یک نخ دارای یک نقطه شروع، یک تسلسل اجرا و یک نقطه پایان است. نخ دارای یک اشاره‌گر دستورالعمل (instruction pointer) است که پیگیری می‌کند در حال حاضر در چه نقطه‌ای از بافت (context) خود در حال اجراست.

  • می‌تواند پیش‌دستی (قطع) شود.

  • می‌تواند در حالی که نخ‌های دیگر در حال اجرا هستند به‌طور موقت موقوف شود (که به آن خوابیدن یا sleeping نیز می‌گویند)؛ به این کار واگذاری (yielding) می‌گویند.

ماژول‌های مدیریت نخ در پایتون

کتابخانه استاندارد پایتون دو ماژول اصلی برای مدیریت نخ‌ها ارائه می‌دهد: _thread و threading.

ماژول _thread

ماژول _thread که به عنوان ماژول سطح پایین نخ نیز شناخته می‌شود، از نسخه ۲ بخشی از کتابخانه استاندارد پایتون بوده است. این ماژول یک API پایه برای مدیریت نخ ارائه می‌دهد و از اجرای هم‌زمان نخ‌ها در یک فضای داده جهانی مشترک پشتیبانی می‌کند. این ماژول شامل قفل‌های ساده (mutexes) برای اهداف هم‌گام‌سازی است.

ماژول threading

ماژول threading که در پایتون ۲.۴ معرفی شد، بر پایه _thread ساخته شده است تا یک API سطح بالاتر و جامع‌تر برای نخ‌بندی ارائه دهد. این ماژول ابزارهای قدرتمندی برای مدیریت نخ‌ها فراهم می‌کند و کار با نخ‌ها را در برنامه‌های پایتون آسان‌تر می‌سازد.

ویژگی‌های کلیدی ماژول threading

ماژول threading تمام متدهای ماژول thread را در دسترس قرار می‌دهد و برخی متدهای اضافی را نیز ارائه می‌کند −

  • threading.activeCount() تعداد اشیاء نخی که فعال هستند را برمی‌گرداند.
  • threading.currentThread() تعداد اشیاء نخ موجود در کنترل نخ فراخواننده را برمی‌گرداند.
  • threading.enumerate() لیستی از تمام اشیاء نخی که در حال حاضر فعال هستند را برمی‌گرداند.

علاوه بر این متدها، ماژول threading دارای کلاس Thread است که نخ‌بندی را پیاده‌سازی می‌کند. متدهای ارائه شده توسط کلاس Thread به شرح زیر است −

  • run() متد run() نقطه ورود یک نخ است.
  • start() متد start() یک نخ را با فراخوانی متد run شروع می‌کند.
  • join([time]) متد join() منتظر می‌ماند تا نخ‌ها خاتمه یابند.
  • isAlive() متد isAlive() بررسی می‌کند که آیا یک نخ همچنان در حال اجراست یا خیر.
  • getName() متد getName() نام یک نخ را برمی‌گرداند.
  • setName() متد setName() نام یک نخ را تنظیم می‌کند.

شروع یک نخ جدید

برای ایجاد و شروع یک نخ جدید در پایتون، می‌توانید از ماژول سطح پایین _thread یا ماژول سطح بالاتر threading استفاده کنید. معمولاً استفاده از ماژول threading به دلیل ویژگی‌های بیشتر و سهولت استفاده توصیه می‌شود. در ادامه می‌توانید هر دو روش را مشاهده کنید.

شروع یک نخ جدید با استفاده از ماژول _thread

متد start_new_thread() از ماژول _thread یک راه پایه برای ایجاد و شروع نخ‌های جدید ارائه می‌دهد. این متد روشی سریع و کارآمد برای ایجاد نخ‌های جدید در لینوکس و ویندوز فراهم می‌کند. سینتکس این متد به شرح زیر است −

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

این فراخوانی متد بلافاصله مقدار را برمی‌گرداند و نخ جدید شروع به اجرای تابع مشخص‌شده با آرگومان‌های داده‌شده می‌کند. هنگامی که تابع مقدار را بازگرداند، نخ خاتمه می‌یابد.

مثال

این مثال نحوه استفاده از ماژول _thread برای ایجاد و اجرای نخ‌ها را نشان می‌دهد. هر نخ تابع print_name را با آرگومان‌های متفاوت اجرا می‌کند. فراخوانی time.sleep(0.5) تضمین می‌کند که برنامه اصلی قبل از خروج، منتظر می‌ماند تا نخ‌ها اجرای خود را به پایان برسانند.

import _thread
import time

def print_name(name, *arg):
   print(name, *arg)

name="Tutorialspoint..."
_thread.start_new_thread(print_name, (name, 1))
_thread.start_new_thread(print_name, (name, 1, 2))

time.sleep(0.5)

هنگامی که کد بالا اجرا شود، خروجی زیر را تولید می‌کند −

Tutorialspoint... 1
Tutorialspoint... 1 2

اگرچه این ماژول برای نخ‌بندی سطح پایین بسیار موثر است، اما ماژول _thread در مقایسه با ماژول threading که ویژگی‌های بیشتر و مدیریت نخ سطح بالاتری ارائه می‌دهد، محدود است.

شروع یک نخ جدید با استفاده از ماژول Threading

ماژول threading کلاس Thread را ارائه می‌دهد که برای ایجاد و مدیریت نخ‌ها استفاده می‌شود.

در اینجا چند مرحله برای شروع یک نخ جدید با استفاده از ماژول threading آمده است −

  • تابعی را که می‌خواهید نخ اجرا کند ایجاد کنید.
  • سپس با انتقال تابع هدف و آرگومان‌های آن، یک شیء Thread با استفاده از کلاس Thread ایجاد کنید.
  • متد start را روی شیء Thread فراخوانی کنید تا اجرا آغاز شود.
  • در صورت تمایل، متد join را فراخوانی کنید تا قبل از ادامه، منتظر بمانید نخ کار خود را تمام کند.

مثال

مثال زیر نحوه ایجاد و شروع نخ‌ها را با استفاده از ماژول threading نشان می‌دهد. این مثال تابعی به نام print_name را اجرا می‌کند که یک نام را به همراه چند آرگومان چاپ می‌کند. این مثال دو نخ ایجاد می‌کند، آن‌ها را با استفاده از متد start() شروع می‌کند و با استفاده از متد join منتظر می‌ماند تا کامل شوند.

import threading
import time

def print_name(name, *args):
    print(name, *args)

name = "Tutorialspoint..."

# Create and start threads
thread1 = threading.Thread(target=print_name, args=(name, 1))
thread2 = threading.Thread(target=print_name, args=(name, 1, 2))

thread1.start()
thread2.start()

# Wait for threads to complete
thread1.join()
thread2.join()

print("Threads are finished...exiting")

هنگامی که کد بالا اجرا شود، خروجی زیر را تولید می‌کند −

Tutorialspoint... 1
Tutorialspoint... 1 2
Threads are finished...exiting

هم‌گام‌سازی نخ‌ها

ماژول threading همراه با پایتون شامل یک مکانیزم قفل‌گذاری ساده برای پیاده‌سازی است که به شما امکان می‌دهد نخ‌ها را هم‌گام‌سازی کنید. یک قفل جدید با فراخوانی متد Lock() ایجاد می‌شود که قفل جدید را برمی‌گرداند.

متد acquire(blocking) از شیء قفل جدید برای اجبار نخ‌ها به اجرای هم‌گام استفاده می‌شود. پارامتر اختیاری blocking به شما امکان می‌دهد کنترل کنید که آیا نخ منتظر به دست آوردن قفل بماند یا خیر.

اگر blocking روی ۰ تنظیم شود، در صورتی که قفل قابل دریافت نباشد، نخ بلافاصله با مقدار ۰ و در صورت دریافت قفل با مقدار ۱ برمی‌گردد. اگر blocking روی ۱ تنظیم شود، نخ مسدود شده و منتظر آزاد شدن قفل می‌ماند.

متد release() از شیء قفل جدید برای آزاد کردن قفل در زمانی که دیگر مورد نیاز نیست استفاده می‌شود.

مثال

import threading
import time

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)
      # Get lock to synchronize threads
      threadLock.acquire()
      print_time(self.name, self.counter, 3)
      # Free lock to release next thread
      threadLock.release()

def print_time(threadName, delay, counter):
   while counter:
      time.sleep(delay)
      print ("%s: %s" % (threadName, time.ctime(time.time())))
      counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
    t.join()
print ("Exiting Main Thread")

هنگامی که کد بالا اجرا شود، خروجی زیر را تولید می‌کند −

Starting Thread-1
Starting Thread-2
Thread-1: Thu Mar 21 09:11:28 2013
Thread-1: Thu Mar 21 09:11:29 2013
Thread-1: Thu Mar 21 09:11:30 2013
Thread-2: Thu Mar 21 09:11:32 2013
Thread-2: Thu Mar 21 09:11:34 2013
Thread-2: Thu Mar 21 09:11:36 2013
Exiting Main Thread

صف اولویت چندنخی (Multithreaded Priority Queue)

ماژول Queue به شما امکان می‌دهد یک شیء صف جدید ایجاد کنید که می‌تواند تعداد مشخصی از آیتم‌ها را نگه دارد. متدهای زیر برای کنترل Queue وجود دارند −

  • get() − متد get() یک آیتم را از صف حذف کرده و برمی‌گرداند.

  • put() − متد put آیتم را به صف اضافه می‌کند.

  • qsize() − متد qsize() تعداد آیتم‌هایی را که در حال حاضر در صف هستند برمی‌گرداند.

  • empty() − متد empty() در صورتی که صف خالی باشد مقدار True و در غیر این صورت False را برمی‌گرداند.

  • full() − متد full() در صورتی که صف پر باشد مقدار True و در غیر این صورت False را برمی‌گرداند.

مثال

import queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, q):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.q = q
   def run(self):
      print ("Starting " + self.name)
      process_data(self.name, self.q)
      print ("Exiting " + self.name)

def process_data(threadName, q):
   while not exitFlag:
      queueLock.acquire()
      if not workQueue.empty():
         data = q.get()
         queueLock.release()
         print ("%s processing %s" % (threadName, data))
      else:
         queueLock.release()
         time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

# Create new threads
for tName in threadList:
   thread = myThread(threadID, tName, workQueue)
   thread.start()
   threads.append(thread)
   threadID += 1

# Fill the queue
queueLock.acquire()
for word in nameList:
   workQueue.put(word)
queueLock.release()

# Wait for queue to empty
while not workQueue.empty():
   pass

# Notify threads it's time to exit
exitFlag = 1

# Wait for all threads to complete
for t in threads:
   t.join()
print ("Exiting Main Thread")

هنگامی که کد بالا اجرا شود، خروجی زیر را تولید می‌کند −

Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

پیشرفت مطالعه: وضعیت خوانده‌شدن این درس فقط در همین مرورگر ذخیره می‌شود؛ بدون نیاز به حساب کاربری.