آزادسازی همزمانی در پایتون: مقایسه ThreadPoolExecutor و ProcessPoolExecutor

پایتون، با وجود اینکه یک زبان برنامه‌نویسی همه‌کاره و پرکاربرد است، به دلیل وجود قفل مفسر سراسری (Global Interpreter Lock - GIL) محدودیت‌هایی در زمینه موازی‌سازی واقعی دارد. ماژول concurrent.futures یک رابط سطح بالا برای اجرای ناهمگام فراخوانی‌ها (callables) فراهم می‌کند و راهی برای دور زدن برخی از این محدودیت‌ها و بهبود عملکرد برای انواع خاصی از وظایف ارائه می‌دهد. این ماژول دو کلاس کلیدی را فراهم می‌کند: ThreadPoolExecutor و ProcessPoolExecutor. این راهنمای جامع به بررسی هر دو می‌پردازد، تفاوت‌ها، نقاط قوت و ضعف آن‌ها را برجسته می‌کند و با ارائه مثال‌های عملی به شما کمک می‌کند تا اجراکننده مناسب را برای نیازهای خود انتخاب کنید.

درک همزمانی و موازی‌سازی

قبل از پرداختن به جزئیات هر اجراکننده، درک مفاهیم همزمانی (concurrency) و موازی‌سازی (parallelism) بسیار مهم است. این اصطلاحات اغلب به جای یکدیگر استفاده می‌شوند، اما معانی متمایزی دارند:

• همزمانی (Concurrency): به مدیریت چندین وظیفه در یک زمان می‌پردازد. این مفهوم به ساختاردهی کد شما برای مدیریت چندین کار به ظاهر همزمان مربوط می‌شود، حتی اگر در واقع بر روی یک هسته پردازنده به صورت نوبتی اجرا شوند. آن را مانند آشپزی تصور کنید که چندین قابلمه را روی یک اجاق گاز مدیریت می‌کند – همه آن‌ها دقیقاً در یک لحظه نمی‌جوشند، اما آشپز همه آن‌ها را مدیریت می‌کند.
• موازی‌سازی (Parallelism): شامل اجرای واقعی چندین وظیفه در *یک* زمان است، که معمولاً با استفاده از چندین هسته پردازنده انجام می‌شود. این مانند داشتن چندین آشپز است که هر کدام به طور همزمان روی بخش متفاوتی از غذا کار می‌کنند.

GIL در پایتون تا حد زیادی از موازی‌سازی واقعی برای وظایف وابسته به CPU هنگام استفاده از نخ‌ها (threads) جلوگیری می‌کند. این به این دلیل است که GIL تنها به یک نخ اجازه می‌دهد تا در هر لحظه کنترل مفسر پایتون را در دست داشته باشد. با این حال، برای وظایف وابسته به I/O، که در آن برنامه بیشتر وقت خود را صرف انتظار برای عملیات خارجی مانند درخواست‌های شبکه یا خواندن از دیسک می‌کند، نخ‌ها همچنان می‌توانند با اجازه دادن به اجرای نخ‌های دیگر در حین انتظار، بهبود عملکرد قابل توجهی ایجاد کنند.

معرفی ماژول `concurrent.futures`

ماژول concurrent.futures فرآیند اجرای ناهمگام وظایف را ساده می‌کند. این ماژول یک رابط سطح بالا برای کار با نخ‌ها و فرآیندها فراهم می‌کند و بسیاری از پیچیدگی‌های مربوط به مدیریت مستقیم آن‌ها را پنهان می‌سازد. مفهوم اصلی «اجراکننده» (executor) است که اجرای وظایف ارسال شده را مدیریت می‌کند. دو اجراکننده اصلی عبارتند از:

• ThreadPoolExecutor: از یک استخر از نخ‌ها برای اجرای وظایف استفاده می‌کند. برای وظایف وابسته به I/O مناسب است.
• ProcessPoolExecutor: از یک استخر از فرآیندها برای اجرای وظایف استفاده می‌کند. برای وظایف وابسته به CPU مناسب است.

ThreadPoolExecutor: بهره‌گیری از نخ‌ها برای وظایف وابسته به I/O

ThreadPoolExecutor یک استخر از نخ‌های کارگر (worker threads) برای اجرای وظایف ایجاد می‌کند. به دلیل وجود GIL، نخ‌ها برای عملیات محاسباتی سنگین که از موازی‌سازی واقعی سود می‌برند، ایده‌آل نیستند. با این حال، آن‌ها در سناریوهای وابسته به I/O عالی عمل می‌کنند. بیایید نحوه استفاده از آن را بررسی کنیم:

استفاده پایه

در اینجا یک مثال ساده از استفاده ThreadPoolExecutor برای دانلود همزمان چندین صفحه وب آورده شده است:

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        print(f"Downloaded {url}: {len(response.content)} bytes")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # Submit each URL to the executor
    futures = [executor.submit(download_page, url) for url in urls]

    # Wait for all tasks to complete
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Total bytes downloaded: {total_bytes}")
print(f"Time taken: {time.time() - start_time:.2f} seconds")

توضیح:

1. ما ماژول‌های لازم را وارد می‌کنیم: concurrent.futures، requests و time.
2. لیستی از URL‌ها برای دانلود تعریف می‌کنیم.
3. تابع download_page محتوای یک URL داده شده را بازیابی می‌کند. مدیریت خطا با استفاده از `try...except` و `response.raise_for_status()` برای گرفتن مشکلات احتمالی شبکه گنجانده شده است.
4. ما یک ThreadPoolExecutor با حداکثر ۴ نخ کارگر ایجاد می‌کنیم. آرگومان max_workers حداکثر تعداد نخ‌هایی را که می‌توانند به طور همزمان استفاده شوند کنترل می‌کند. تنظیم آن بیش از حد بالا ممکن است همیشه عملکرد را بهبود نبخشد، به خصوص در وظایف وابسته به I/O که پهنای باند شبکه اغلب گلوگاه است.
5. ما از یک list comprehension برای ارسال هر URL به اجراکننده با استفاده از executor.submit(download_page, url) استفاده می‌کنیم. این برای هر وظیفه یک شی Future برمی‌گرداند.
6. تابع concurrent.futures.as_completed(futures) یک تکرارکننده (iterator) برمی‌گرداند که futureها را به محض تکمیل شدن، بازمی‌گرداند. این کار از انتظار برای تمام شدن همه وظایف قبل از پردازش نتایج جلوگیری می‌کند.
7. ما از طریق futureهای تکمیل شده تکرار می‌کنیم و نتیجه هر وظیفه را با استفاده از future.result() بازیابی می‌کنیم و کل بایت‌های دانلود شده را جمع می‌زنیم. مدیریت خطا در داخل `download_page` تضمین می‌کند که خرابی‌های فردی کل فرآیند را از کار نیندازد.
8. در نهایت، کل بایت‌های دانلود شده و زمان صرف شده را چاپ می‌کنیم.

مزایای ThreadPoolExecutor

• همزمانی ساده‌شده: یک رابط تمیز و آسان برای مدیریت نخ‌ها فراهم می‌کند.
• عملکرد در وظایف وابسته به I/O: برای وظایفی که بخش قابل توجهی از زمان خود را صرف انتظار برای عملیات I/O می‌کنند، مانند درخواست‌های شبکه، خواندن فایل یا کوئری‌های پایگاه داده، عالی است.
• سربار کمتر: نخ‌ها به طور کلی سربار کمتری نسبت به فرآیندها دارند، که آن‌ها را برای وظایفی که شامل تعویض زمینه (context switching) مکرر هستند، کارآمدتر می‌کند.

محدودیت‌های ThreadPoolExecutor

• محدودیت GIL: GIL موازی‌سازی واقعی را برای وظایف وابسته به CPU محدود می‌کند. تنها یک نخ می‌تواند بایت‌کد پایتون را در یک زمان اجرا کند، که مزایای هسته‌های چندگانه را خنثی می‌کند.
• پیچیدگی اشکال‌زدایی: اشکال‌زدایی برنامه‌های چندنخی به دلیل شرایط رقابتی (race conditions) و سایر مسائل مربوط به همزمانی می‌تواند چالش‌برانگیز باشد.

ProcessPoolExecutor: آزادسازی چندپردازشی برای وظایف وابسته به CPU

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

استفاده پایه

یک وظیفه محاسباتی سنگین مانند محاسبه مجموع مربعات برای یک محدوده بزرگ از اعداد را در نظر بگیرید. در اینجا نحوه استفاده از ProcessPoolExecutor برای موازی‌سازی این وظیفه آورده شده است:

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Process ID: {pid}, Calculating sum of squares from {start} to {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": #Important for avoiding recursive spawning in some environments
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Total sum of squares: {total_sum}")
    print(f"Time taken: {time.time() - start_time:.2f} seconds")

توضیح:

1. ما یک تابع sum_of_squares تعریف می‌کنیم که مجموع مربعات را برای یک محدوده معین از اعداد محاسبه می‌کند. ما از `os.getpid()` برای دیدن اینکه کدام فرآیند هر محدوده را اجرا می‌کند، استفاده می‌کنیم.
2. ما اندازه محدوده و تعداد فرآیندهای مورد استفاده را تعریف می‌کنیم. لیست ranges برای تقسیم محدوده کل محاسبه به تکه‌های کوچکتر، یکی برای هر فرآیند، ایجاد می‌شود.
3. ما یک ProcessPoolExecutor با تعداد مشخصی از فرآیندهای کارگر ایجاد می‌کنیم.
4. ما هر محدوده را با استفاده از executor.submit(sum_of_squares, start, end) به اجراکننده ارسال می‌کنیم.
5. ما نتایج را از هر future با استفاده از future.result() جمع‌آوری می‌کنیم.
6. ما نتایج همه فرآیندها را برای بدست آوردن مجموع نهایی جمع می‌کنیم.

نکته مهم: هنگام استفاده از ProcessPoolExecutor، به ویژه در ویندوز، باید کدی را که اجراکننده را ایجاد می‌کند، در یک بلوک if __name__ == "__main__": قرار دهید. این کار از ایجاد بازگشتی فرآیندها جلوگیری می‌کند، که می‌تواند منجر به خطا و رفتار غیرمنتظره شود. دلیل این امر این است که ماژول در هر فرآیند فرزند دوباره وارد (import) می‌شود.

مزایای ProcessPoolExecutor

• موازی‌سازی واقعی: محدودیت GIL را برطرف می‌کند و امکان موازی‌سازی واقعی را در سیستم‌های چند هسته‌ای برای وظایف وابسته به CPU فراهم می‌کند.
• بهبود عملکرد برای وظایف وابسته به CPU: می‌توان به دستاوردهای عملکردی قابل توجهی برای عملیات محاسباتی سنگین دست یافت.
• استحکام: اگر یک فرآیند از کار بیفتد، لزوماً کل برنامه را از کار نمی‌اندازد، زیرا فرآیندها از یکدیگر جدا هستند.

محدودیت‌های ProcessPoolExecutor

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

انتخاب اجراکننده مناسب: ThreadPoolExecutor در مقابل ProcessPoolExecutor

کلید انتخاب بین ThreadPoolExecutor و ProcessPoolExecutor در درک ماهیت وظایف شما نهفته است:

• وظایف وابسته به I/O: اگر وظایف شما بیشتر وقت خود را صرف انتظار برای عملیات I/O می‌کنند (مانند درخواست‌های شبکه، خواندن فایل، کوئری‌های پایگاه داده)، ThreadPoolExecutor به طور کلی انتخاب بهتری است. GIL در این سناریوها کمتر یک گلوگاه است و سربار کمتر نخ‌ها آن‌ها را کارآمدتر می‌کند.
• وظایف وابسته به CPU: اگر وظایف شما محاسباتی سنگین هستند و از چندین هسته استفاده می‌کنند، ProcessPoolExecutor راه حل مناسبی است. این اجراکننده محدودیت GIL را دور می‌زند و امکان موازی‌سازی واقعی را فراهم می‌کند، که منجر به بهبود قابل توجهی در عملکرد می‌شود.

در اینجا جدولی برای خلاصه کردن تفاوت‌های کلیدی آورده شده است:

ویژگی	ThreadPoolExecutor	ProcessPoolExecutor
مدل همزمانی	چندنخی (Multithreading)	چندپردازشی (Multiprocessing)
تأثیر GIL	محدود شده توسط GIL	GIL را دور می‌زند
مناسب برای	وظایف وابسته به I/O	وظایف وابسته به CPU
سربار (Overhead)	کمتر	بیشتر
مصرف حافظه	کمتر	بیشتر
ارتباط بین فرآیندی	لازم نیست (نخ‌ها حافظه را به اشتراک می‌گذارند)	برای اشتراک‌گذاری داده‌ها لازم است
استحکام	کمتر مستحکم (یک خرابی می‌تواند کل فرآیند را تحت تأثیر قرار دهد)	مستحکم‌تر (فرآیندها جدا هستند)

تکنیک‌ها و ملاحظات پیشرفته

ارسال وظایف با آرگومان‌ها

هر دو اجراکننده به شما امکان می‌دهند آرگومان‌ها را به تابعی که اجرا می‌شود، ارسال کنید. این کار از طریق متد submit() انجام می‌شود:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

مدیریت استثناها (Exceptions)

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

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"An exception occurred: {e}")

استفاده از `map` برای وظایف ساده

برای وظایف ساده که در آن می‌خواهید یک تابع یکسان را روی یک دنباله از ورودی‌ها اعمال کنید، متد map() راهی مختصر برای ارسال وظایف فراهم می‌کند:

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

کنترل تعداد کارگران (Workers)

آرگومان max_workers در هر دو ThreadPoolExecutor و ProcessPoolExecutor حداکثر تعداد نخ‌ها یا فرآیندهایی را که می‌توانند به طور همزمان استفاده شوند، کنترل می‌کند. انتخاب مقدار مناسب برای max_workers برای عملکرد مهم است. یک نقطه شروع خوب، تعداد هسته‌های CPU موجود در سیستم شما است. با این حال، برای وظایف وابسته به I/O، ممکن است از استفاده از نخ‌های بیشتر از هسته‌ها سود ببرید، زیرا نخ‌ها می‌توانند در حین انتظار برای I/O به وظایف دیگر سوئیچ کنند. آزمایش و پروفایل‌سازی اغلب برای تعیین مقدار بهینه ضروری است.

نظارت بر پیشرفت

ماژول concurrent.futures مکانیزم‌های داخلی برای نظارت مستقیم بر پیشرفت وظایف ارائه نمی‌دهد. با این حال، می‌توانید با استفاده از callbackها یا متغیرهای مشترک، ردیابی پیشرفت خود را پیاده‌سازی کنید. کتابخانه‌هایی مانند `tqdm` می‌توانند برای نمایش نوارهای پیشرفت ادغام شوند.

مثال‌های دنیای واقعی

بیایید برخی از سناریوهای دنیای واقعی را در نظر بگیریم که در آن‌ها ThreadPoolExecutor و ProcessPoolExecutor می‌توانند به طور موثر به کار روند:

• وب اسکرپینگ (Web Scraping): دانلود و تجزیه چندین صفحه وب به طور همزمان با استفاده از ThreadPoolExecutor. هر نخ می‌تواند یک صفحه وب متفاوت را مدیریت کند و سرعت کلی اسکرپینگ را بهبود بخشد. به شرایط خدمات وب‌سایت‌ها توجه داشته باشید و از بارگذاری بیش از حد بر روی سرورهای آن‌ها خودداری کنید.
• پردازش تصویر: اعمال فیلترهای تصویر یا تبدیل‌ها بر روی مجموعه بزرگی از تصاویر با استفاده از ProcessPoolExecutor. هر فرآیند می‌تواند یک تصویر متفاوت را مدیریت کند و از چندین هسته برای پردازش سریع‌تر بهره ببرد. برای دستکاری کارآمد تصویر، کتابخانه‌هایی مانند OpenCV را در نظر بگیرید.
• تحلیل داده: انجام محاسبات پیچیده بر روی مجموعه داده‌های بزرگ با استفاده از ProcessPoolExecutor. هر فرآیند می‌تواند زیرمجموعه‌ای از داده‌ها را تحلیل کند و زمان کلی تحلیل را کاهش دهد. Pandas و NumPy کتابخانه‌های محبوبی برای تحلیل داده در پایتون هستند.
• یادگیری ماشین: آموزش مدل‌های یادگیری ماشین با استفاده از ProcessPoolExecutor. برخی از الگوریتم‌های یادگیری ماشین می‌توانند به طور موثر موازی‌سازی شوند و زمان آموزش را کاهش دهند. کتابخانه‌هایی مانند scikit-learn و TensorFlow از موازی‌سازی پشتیبانی می‌کنند.
• کدگذاری ویدئو: تبدیل فایل‌های ویدئویی به فرمت‌های مختلف با استفاده از ProcessPoolExecutor. هر فرآیند می‌تواند یک بخش متفاوت از ویدئو را کدگذاری کند و فرآیند کلی کدگذاری را سریع‌تر کند.

ملاحظات جهانی

هنگام توسعه برنامه‌های همزمان برای مخاطبان جهانی، توجه به موارد زیر مهم است:

• مناطق زمانی: هنگام کار با عملیات حساس به زمان، به مناطق زمانی توجه داشته باشید. از کتابخانه‌هایی مانند pytz برای مدیریت تبدیل مناطق زمانی استفاده کنید.
• محلی‌سازی (Locales): اطمینان حاصل کنید که برنامه شما محلی‌سازی‌های مختلف را به درستی مدیریت می‌کند. از کتابخانه‌هایی مانند locale برای قالب‌بندی اعداد، تاریخ‌ها و ارزها مطابق با محلی کاربر استفاده کنید.
• رمزگذاری کاراکترها: از یونیکد (UTF-8) به عنوان رمزگذاری پیش‌فرض کاراکترها برای پشتیبانی از طیف گسترده‌ای از زبان‌ها استفاده کنید.
• بین‌المللی‌سازی (i18n) و محلی‌سازی (l10n): برنامه خود را طوری طراحی کنید که به راحتی بین‌المللی و محلی‌سازی شود. از gettext یا سایر کتابخانه‌های ترجمه برای ارائه ترجمه برای زبان‌های مختلف استفاده کنید.
• تأخیر شبکه: هنگام ارتباط با سرویس‌های راه دور، تأخیر شبکه را در نظر بگیرید. مهلت‌های زمانی (timeouts) و مدیریت خطای مناسب را برای اطمینان از انعطاف‌پذیری برنامه خود در برابر مشکلات شبکه پیاده‌سازی کنید. موقعیت جغرافیایی سرورها می‌تواند تأخیر را به طور قابل توجهی تحت تأثیر قرار دهد. برای بهبود عملکرد برای کاربران در مناطق مختلف، استفاده از شبکه‌های تحویل محتوا (CDN) را در نظر بگیرید.

نتیجه‌گیری

ماژول concurrent.futures یک راه قدرتمند و راحت برای معرفی همزمانی و موازی‌سازی در برنامه‌های پایتون شما فراهم می‌کند. با درک تفاوت‌های بین ThreadPoolExecutor و ProcessPoolExecutor و با در نظر گرفتن دقیق ماهیت وظایف خود، می‌توانید به طور قابل توجهی عملکرد و پاسخگویی کد خود را بهبود بخشید. به یاد داشته باشید که کد خود را پروفایل کنید و با تنظیمات مختلف آزمایش کنید تا تنظیمات بهینه را برای مورد استفاده خاص خود پیدا کنید. همچنین، از محدودیت‌های GIL و پیچیدگی‌های بالقوه برنامه‌نویسی چندنخی و چندپردازشی آگاه باشید. با برنامه‌ریزی و پیاده‌سازی دقیق، می‌توانید پتانسیل کامل همزمانی در پایتون را آزاد کرده و برنامه‌های قوی و مقیاس‌پذیر برای مخاطبان جهانی ایجاد کنید.