تسلط بر اصول اولیه Threading در پایتون: Lock، RLock، Semaphore و Condition Variables

در حوزه برنامه‌نویسی همزمان، پایتون ابزارهای قدرتمندی برای مدیریت چندین رشته (Thread) و تضمین یکپارچگی داده‌ها ارائه می‌دهد. درک و استفاده از اصول اولیه Threading مانند Lock، RLock، Semaphore و Condition Variables برای ساخت برنامه‌های چندرشته‌ای قوی و کارآمد بسیار حیاتی است. این راهنمای جامع به بررسی هر یک از این اصول اولیه می‌پردازد و مثال‌های عملی و بینش‌هایی را برای کمک به شما در تسلط بر همزمانی در پایتون ارائه می‌دهد.

چرا اصول اولیه Threading اهمیت دارند؟

چندرشتگی به شما امکان می‌دهد چندین بخش از یک برنامه را به طور همزمان اجرا کنید و به طور بالقوه عملکرد را بهبود می‌بخشد، به خصوص در وظایف وابسته به ورودی/خروجی (I/O-bound). با این حال، دسترسی همزمان به منابع مشترک می‌تواند منجر به شرایط رقابتی (race conditions)، خرابی داده‌ها و سایر مشکلات مربوط به همزمانی شود. اصول اولیه Threading مکانیزم‌هایی را برای همگام‌سازی اجرای رشته‌ها، جلوگیری از تضادها و تضمین ایمنی رشته (thread safety) فراهم می‌کنند.

سناریویی را تصور کنید که چندین رشته در تلاشند تا همزمان یک موجودی حساب بانکی مشترک را به‌روزرسانی کنند. بدون همگام‌سازی مناسب، یک رشته ممکن است تغییرات ایجاد شده توسط رشته دیگر را بازنویسی کند که منجر به موجودی نهایی نادرست می‌شود. اصول اولیه Threading مانند کنترل‌کننده‌های ترافیک عمل می‌کنند و تضمین می‌کنند که فقط یک رشته در هر زمان به بخش حیاتی (critical section) کد دسترسی پیدا کند و از چنین مشکلاتی جلوگیری می‌کند.

قفل سراسری مفسر (GIL) پایتون

قبل از پرداختن به اصول اولیه، درک قفل سراسری مفسر (Global Interpreter Lock - GIL) در پایتون ضروری است. GIL یک mutex است که تنها به یک رشته اجازه می‌دهد تا در هر زمان کنترل مفسر پایتون را در اختیار داشته باشد. این بدان معناست که حتی در پردازنده‌های چند هسته‌ای، اجرای موازی واقعی بایت‌کد پایتون محدود است. در حالی که GIL می‌تواند برای وظایف وابسته به CPU یک گلوگاه باشد، Threading همچنان می‌تواند برای عملیات‌های وابسته به I/O که در آن رشته‌ها بیشتر وقت خود را منتظر منابع خارجی می‌گذرانند، مفید باشد. علاوه بر این، کتابخانه‌هایی مانند NumPy اغلب GIL را برای وظایف محاسباتی فشرده آزاد می‌کنند و موازی‌سازی واقعی را امکان‌پذیر می‌سازند.

1. اصل اولیه Lock

Lock چیست؟

یک Lock (که به عنوان mutex نیز شناخته می‌شود) ابتدایی‌ترین اصل همگام‌سازی است. این امکان را فراهم می‌کند که تنها یک رشته در هر زمان Lock را بدست آورد. هر رشته دیگری که بخواهد Lock را بدست آورد، مسدود (منتظر) می‌شود تا Lock آزاد شود. این امر دسترسی انحصاری به یک منبع مشترک را تضمین می‌کند.

متدهای Lock

• acquire([blocking]): Lock را بدست می‌آورد. اگر blocking برابر با True باشد (پیش‌فرض)، رشته تا زمانی که Lock در دسترس قرار گیرد، مسدود می‌شود. اگر blocking برابر با False باشد، متد بلافاصله بازمی‌گردد. اگر Lock بدست آید، True و در غیر این صورت False را برمی‌گرداند.
• release(): Lock را آزاد می‌کند و به رشته دیگری اجازه می‌دهد تا آن را بدست آورد. فراخوانی release() بر روی یک Lock که آزاد نیست، یک RuntimeError ایجاد می‌کند.
• locked(): اگر Lock در حال حاضر بدست آمده باشد، True و در غیر این صورت False را برمی‌گرداند.

مثال: محافظت از یک شمارنده مشترک

سناریویی را در نظر بگیرید که چندین رشته یک شمارنده مشترک را افزایش می‌دهند. بدون Lock، مقدار نهایی شمارنده ممکن است به دلیل شرایط رقابتی نادرست باشد.

            
import threading

counter = 0
lock = threading.Lock()

def increment():
 global counter
 for _ in range(100000):
 with lock:
 counter += 1

threads = []
for _ in range(5):
 t = threading.Thread(target=increment)
 threads.append(t)
 t.start()

for t in threads:
 t.join()

print(f"Final counter value: {counter}")

            

              
                Copy
              
            
          

در این مثال، دستور with lock: تضمین می‌کند که تنها یک رشته می‌تواند در هر زمان به متغیر counter دسترسی پیدا کرده و آن را تغییر دهد. دستور with به طور خودکار Lock را در ابتدای بلوک بدست آورده و در پایان آن را آزاد می‌کند، حتی اگر استثنایی رخ دهد. این ساختار جایگزین تمیزتر و ایمن‌تری برای فراخوانی دستی lock.acquire() و lock.release() ارائه می‌دهد.

آنالوژی دنیای واقعی

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

2. اصل اولیه RLock

RLock چیست؟

یک RLock (reentrant lock) نوع پیشرفته‌تری از Lock است که به همان رشته اجازه می‌دهد چندین بار Lock را بدون مسدود شدن بدست آورد. این امر در شرایطی مفید است که یک تابع که یک Lock را در اختیار دارد، تابع دیگری را فراخوانی می‌کند که آن نیز نیاز به بدست آوردن همان Lock دارد. Lock‌های معمولی در این وضعیت باعث بن‌بست (deadlock) می‌شوند.

متدهای RLock

متدهای RLock همانند Lock هستند: acquire([blocking])، release() و locked(). با این حال، رفتار متفاوت است. به صورت داخلی، RLock یک شمارنده را حفظ می‌کند که تعداد دفعاتی که توسط یک رشته خاص بدست آمده است را ردیابی می‌کند. Lock تنها زمانی آزاد می‌شود که متد release() به همان تعداد دفعاتی که Lock بدست آمده، فراخوانی شود.

مثال: تابع بازگشتی با RLock

یک تابع بازگشتی را در نظر بگیرید که نیاز به دسترسی به یک منبع مشترک دارد. بدون RLock، تابع هنگامی که به صورت بازگشتی سعی در بدست آوردن Lock کند، دچار بن‌بست می‌شود.

            
import threading

lock = threading.RLock()


def recursive_function(n):
 with lock:
 if n <= 0:
 return
 print(f"Thread {threading.current_thread().name}: Processing {n}")
 recursive_function(n - 1)


thread = threading.Thread(target=recursive_function, args=(5,))
thread.start()
thread.join()

            

              
                Copy
              
            
          

در این مثال، RLock به recursive_function اجازه می‌دهد تا چندین بار Lock را بدون مسدود شدن بدست آورد. هر فراخوانی recursive_function Lock را بدست می‌آورد و هر بازگشت آن را آزاد می‌کند. Lock تنها زمانی به طور کامل آزاد می‌شود که فراخوانی اولیه به recursive_function بازگردد.

آنالوژی دنیای واقعی

یک مدیر را تصور کنید که نیاز به دسترسی به پرونده‌های محرمانه یک شرکت دارد. RLock مانند یک کارت دسترسی ویژه است که به مدیر اجازه می‌دهد چندین بار وارد بخش‌های مختلف اتاق پرونده شود بدون اینکه هر بار نیاز به احراز هویت مجدد داشته باشد. مدیر تنها زمانی باید کارت را برگرداند که کارش با پرونده‌ها کاملاً تمام شده و اتاق پرونده را ترک کرده باشد.

3. اصل اولیه Semaphore

Semaphore چیست؟

یک Semaphore یک اصل همگام‌سازی عمومی‌تر از Lock است. این یک شمارنده را مدیریت می‌کند که تعداد منابع موجود را نشان می‌دهد. رشته‌ها می‌توانند یک Semaphore را با کاهش شمارنده (اگر مثبت باشد) بدست آورند یا تا زمانی که شمارنده مثبت شود، مسدود شوند. رشته‌ها یک Semaphore را با افزایش شمارنده آزاد می‌کنند و به طور بالقوه یک رشته مسدود شده را بیدار می‌کنند.

متدهای Semaphore

• acquire([blocking]): Semaphore را بدست می‌آورد. اگر blocking برابر با True باشد (پیش‌فرض)، رشته تا زمانی که شمارنده Semaphore بزرگتر از صفر شود، مسدود می‌شود. اگر blocking برابر با False باشد، متد بلافاصله بازمی‌گردد. اگر Semaphore بدست آید، True و در غیر این صورت False را برمی‌گرداند. شمارنده داخلی را یک واحد کاهش می‌دهد.
• release(): Semaphore را آزاد می‌کند و شمارنده داخلی را یک واحد افزایش می‌دهد. اگر رشته‌های دیگری منتظر در دسترس قرار گرفتن Semaphore باشند، یکی از آنها بیدار می‌شود.
• get_value(): مقدار فعلی شمارنده داخلی را برمی‌گرداند.

مثال: محدود کردن دسترسی همزمان به یک منبع

سناریویی را در نظر بگیرید که می‌خواهید تعداد اتصالات همزمان به یک پایگاه داده را محدود کنید. یک Semaphore می‌تواند برای کنترل تعداد رشته‌هایی که می‌توانند در هر زمان به پایگاه داده دسترسی داشته باشند، استفاده شود.

            
import threading
import time
import random

semaphore = threading.Semaphore(3)  # Allow only 3 concurrent connections

def database_access():
 with semaphore:
 print(f"Thread {threading.current_thread().name}: Accessing database...")
 time.sleep(random.randint(1, 3))  # Simulate database access
 print(f"Thread {threading.current_thread().name}: Releasing database...")


threads = []
for i in range(5):
 t = threading.Thread(target=database_access, name=f"Thread-{i}")
 threads.append(t)
 t.start()

for t in threads:
 t.join()

            

              
                Copy
              
            
          

در این مثال، Semaphore با مقدار 3 مقداردهی اولیه شده است، به این معنی که تنها 3 رشته می‌توانند Semaphore را بدست آورند (و به پایگاه داده دسترسی پیدا کنند) در هر زمان. رشته‌های دیگر مسدود می‌شوند تا زمانی که یک Semaphore آزاد شود. این به جلوگیری از بارگذاری بیش از حد پایگاه داده کمک می‌کند و تضمین می‌کند که می‌تواند درخواست‌های همزمان را به طور کارآمد مدیریت کند.

آنالوژی دنیای واقعی

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

4. اصل اولیه Condition Variable

Condition Variable چیست؟

یک Condition Variable یک اصل همگام‌سازی پیشرفته‌تر است که به رشته‌ها اجازه می‌دهد منتظر شوند تا یک شرط خاص برقرار شود. این همیشه با یک Lock (یا Lock یا RLock) مرتبط است. رشته‌ها می‌توانند روی Condition Variable منتظر بمانند، Lock مرتبط را آزاد کرده و اجرای خود را به حالت تعلیق درآورند تا زمانی که رشته دیگری شرط را سیگنال دهد. این برای سناریوهای تولیدکننده-مصرف‌کننده یا موقعیت‌هایی که رشته‌ها نیاز به هماهنگی بر اساس رویدادهای خاص دارند، حیاتی است.

متدهای Condition Variable

• acquire([blocking]): Lock زیربنایی را بدست می‌آورد. همانند متد acquire Lock مرتبط.
• release(): Lock زیربنایی را آزاد می‌کند. همانند متد release Lock مرتبط.
• wait([timeout]): Lock زیربنایی را آزاد می‌کند و تا زمانی که توسط فراخوانی notify() یا notify_all() بیدار شود، منتظر می‌ماند. Lock قبل از بازگشت wait() دوباره بدست می‌آید. یک آرگومان اختیاری timeout حداکثر زمان انتظار را مشخص می‌کند.
• notify(n=1): حداکثر n رشته منتظر را بیدار می‌کند.
• notify_all(): تمام رشته‌های منتظر را بیدار می‌کند.

مثال: مسئله تولیدکننده-مصرف‌کننده

مسئله کلاسیک تولیدکننده-مصرف‌کننده شامل یک یا چند تولیدکننده است که داده تولید می‌کنند و یک یا چند مصرف‌کننده که داده را پردازش می‌کنند. یک بافر مشترک برای ذخیره داده‌ها استفاده می‌شود و تولیدکنندگان و مصرف‌کنندگان باید دسترسی به بافر را همگام‌سازی کنند تا از شرایط رقابتی جلوگیری شود.

            
import threading
import time
import random


buffer = []
buffer_size = 5
condition = threading.Condition()


def producer():
 global buffer
 while True:
 with condition:
 if len(buffer) == buffer_size:
 print("Buffer is full, producer waiting...")
 condition.wait()

 item = random.randint(1, 100)
 buffer.append(item)
 print(f"Produced: {item}, Buffer: {buffer}")
 condition.notify()
 time.sleep(random.random())


def consumer():
 global buffer
 while True:
 with condition:
 if not buffer:
 print("Buffer is empty, consumer waiting...")
 condition.wait()

 item = buffer.pop(0)
 print(f"Consumed: {item}, Buffer: {buffer}")
 condition.notify()
 time.sleep(random.random())


producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

producer_thread.start()
consumer_thread.start()

producer_thread.join()
consumer_thread.join()

            

              
                Copy
              
            
          

در این مثال، متغیر condition برای همگام‌سازی رشته‌های تولیدکننده و مصرف‌کننده استفاده می‌شود. تولیدکننده اگر بافر پر باشد منتظر می‌ماند و مصرف‌کننده اگر بافر خالی باشد منتظر می‌ماند. هنگامی که تولیدکننده یک آیتم را به بافر اضافه می‌کند، به مصرف‌کننده اطلاع می‌دهد. هنگامی که مصرف‌کننده یک آیتم را از بافر حذف می‌کند، به تولیدکننده اطلاع می‌دهد. دستور with condition: تضمین می‌کند که Lock مرتبط با Condition Variable به درستی بدست آمده و آزاد می‌شود.

آنالوژی دنیای واقعی

یک انبار را تصور کنید که تولیدکنندگان (تامین‌کنندگان) کالا تحویل می‌دهند و مصرف‌کنندگان (مشتریان) کالا را دریافت می‌کنند. بافر مشترک مانند موجودی انبار است. Condition Variable مانند یک سیستم ارتباطی است که به تامین‌کنندگان و مشتریان اجازه می‌دهد فعالیت‌های خود را هماهنگ کنند. اگر انبار پر باشد، تامین‌کنندگان منتظر می‌مانند تا فضا خالی شود. اگر انبار خالی باشد، مشتریان منتظر می‌مانند تا کالا برسد. هنگامی که کالا تحویل داده می‌شود، تامین‌کنندگان به مشتریان اطلاع می‌دهند. هنگامی که کالا دریافت می‌شود، مشتریان به تامین‌کنندگان اطلاع می‌دهند.

انتخاب اصل اولیه مناسب

انتخاب اصل اولیه Threading مناسب برای مدیریت موثر همزمانی بسیار مهم است. در اینجا خلاصه‌ای برای کمک به شما در انتخاب آورده شده است:

• Lock: زمانی استفاده کنید که نیاز به دسترسی انحصاری به یک منبع مشترک دارید و فقط یک رشته باید بتواند در یک زمان به آن دسترسی داشته باشد.
• RLock: زمانی استفاده کنید که ممکن است همان رشته نیاز به بدست آوردن Lock چندین بار داشته باشد، مانند توابع بازگشتی یا بخش‌های حیاتی تودرتو.
• Semaphore: زمانی استفاده کنید که نیاز به محدود کردن تعداد دسترسی‌های همزمان به یک منبع دارید، مانند محدود کردن تعداد اتصالات پایگاه داده یا تعداد رشته‌هایی که یک کار خاص را انجام می‌دهند.
• Condition Variable: زمانی استفاده کنید که رشته‌ها نیاز به انتظار برای برقراری یک شرط خاص دارند، مانند سناریوهای تولیدکننده-مصرف‌کننده یا زمانی که رشته‌ها نیاز به هماهنگی بر اساس رویدادهای خاص دارند.

مشکلات رایج و بهترین روش‌ها

کار با اصول اولیه Threading می‌تواند چالش‌برانگیز باشد و مهم است که از مشکلات رایج و بهترین روش‌ها آگاه باشید:

• بن‌بست (Deadlock): زمانی رخ می‌دهد که دو یا چند رشته به طور نامحدود مسدود شده‌اند و منتظر یکدیگر برای آزاد کردن منابع هستند. با بدست آوردن Lock‌ها به ترتیبی ثابت و استفاده از timeout هنگام بدست آوردن Lock‌ها از بن‌بست جلوگیری کنید.
• شرایط رقابتی (Race Conditions): زمانی رخ می‌دهد که نتیجه یک برنامه به ترتیب غیرقابل پیش‌بینی اجرای رشته‌ها بستگی دارد. با استفاده از اصول اولیه همگام‌سازی مناسب برای محافظت از منابع مشترک، از شرایط رقابتی جلوگیری کنید.
• گرسنگی (Starvation): زمانی رخ می‌دهد که یک رشته به طور مکرر از دسترسی به یک منبع محروم می‌شود، حتی اگر منبع در دسترس باشد. با استفاده از سیاست‌های زمان‌بندی مناسب و جلوگیری از وارونگی اولویت (priority inversions) عدالت را تضمین کنید.
• همگام‌سازی بیش از حد (Over-Synchronization): استفاده از تعداد بیش از حد اصول اولیه همگام‌سازی می‌تواند عملکرد را کاهش داده و پیچیدگی را افزایش دهد. فقط در صورت لزوم از همگام‌سازی استفاده کنید و بخش‌های حیاتی را تا حد امکان کوتاه نگه دارید.
• همیشه Lock‌ها را آزاد کنید: اطمینان حاصل کنید که همیشه Lock‌ها را پس از اتمام کار با آنها آزاد می‌کنید. از دستور with برای بدست آوردن و آزاد کردن خودکار Lock‌ها استفاده کنید، حتی اگر استثنایی رخ دهد.
• تست کامل: کد چندرشته‌ای خود را به طور کامل تست کنید تا مشکلات مربوط به همزمانی را شناسایی و رفع کنید. از ابزارهایی مانند thread sanitizers و memory checkers برای شناسایی مشکلات احتمالی استفاده کنید.

نتیجه‌گیری

تسلط بر اصول اولیه Threading پایتون برای ساخت برنامه‌های همزمان قوی و کارآمد ضروری است. با درک هدف و کاربرد Lock، RLock، Semaphore و Condition Variables، می‌توانید همگام‌سازی رشته‌ها را به طور موثر مدیریت کنید، از شرایط رقابتی جلوگیری کنید و از مشکلات رایج همزمانی دوری کنید. به یاد داشته باشید که اصل اولیه مناسب را برای کار خاص انتخاب کنید، از بهترین روش‌ها پیروی کنید و کد خود را به طور کامل تست کنید تا ایمنی رشته و عملکرد بهینه را تضمین کنید. قدرت همزمانی را در آغوش بگیرید و پتانسیل کامل برنامه‌های پایتون خود را آزاد کنید!