آموزش concurrent.futures در پایتون: اجرای همزمان برنامه‌ها مثل یک حرفه‌ای

تا حالا شده کدی بنویسید که اجرای آن به خاطر دانلود صدها فایل یا انجام محاسبات ریاضی سنگین، دقیقه‌ها یا حتی ساعت‌ها طول بکشد؟ در دنیای مدرن برنامه‌نویسی، زمان طلاست. پایتون برای حل این مشکل ابزار قدرتمندی به نام ماژول concurrent.futures را در اختیار ما قرار داده است. این کتابخانه به شما اجازه می‌دهد تا کارهای خود را به صورت همزمان (Concurrency) یا موازی (Parallelism) اجرا کنید و سرعت برنامه‌های خود را به شدت افزایش دهید. در این مقاله به زبان ساده، کاربردی و عمیق یاد می‌گیرید که چطور از این قابلیت برای بهینه‌سازی پروژه‌های خود استفاده کنید.

۱. چرا به concurrent.futures نیاز داریم؟

به طور پیش‌فرض، پایتون کدهای شما را به صورت تک‌رشته‌ای (Single-threaded) اجرا می‌کند. این یعنی خط به خط برنامه شما منتظر می‌ماند تا خط قبلی به طور کامل تمام شود. حالا فرض کنید می‌خواهید ۲۰ سایت مختلف را بررسی کنید و وضعیت پاسخ آن‌ها را بگیرید. اگر بررسی هر سایت ۲ ثانیه طول بکشد، کل برنامه شما ۴۰ ثانیه معطل خواهد شد!

برای رهایی از این محدودیت، پایتون راه‌های مختلفی مثل threading و multiprocessing دارد. اما کار با این کتابخانه‌ها در سطح پایین (Low-level) بسیار پیچیده است و نیاز به قفل‌گذاری (Locks)، مدیریت صف‌ها و کنترل سخت خطاها دارد. اینجاست که ماژول concurrent.futures به عنوان یک رابط کاربری سطح بالا و بسیار ساده وارد میدان می‌شود تا با چند خط کد، تمام این هماهنگی‌ها را پشت صحنه انجام دهد. با استفاده از این ابزار، نوشتن کدهای برنامه‌نوسی همزمان در پایتون به یک کار لذت‌بخش تبدیل می‌شود.

۲. آشنایی با ساختار و مفاهیم اصلی ماژول

این کتابخنه از مفهوم «مجری» یا Executor استفاده می‌کند. شما کارهای خود را به این مجری تحویل می‌دهید و او تصمیم می‌گیرد که چگونه آن‌ها را در بستر مناسب اجرا کند. دو نوع مجری اصلی در این پکیج وجود دارد:

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

۳. کار با ThreadPoolExecutor (بهینه‌سازی I/O)

بیایید با یک مثال واقعی شروع کنیم. فرض کنید می‌خواهیم زمان تاخیر چند وب‌سایت مختلف را اندازه بگیریم. ابتدا کد را به روش معمولی می‌نویسیم و سپس با استفاده از ThreadPoolExecutor آن را چند برابر سریع‌تر می‌کنیم.

در ادامه نمونه کدی را مشاهده می‌کنید که وظیفه شبیه‌سازی دانلود اطلاعات از اینترنت را دارد:

import concurrent.futures
import time
import requests

URLS = [
    'https://httpbin.org/delay/2',
    'https://httpbin.org/delay/1',
    'https://httpbin.org/delay/3',
    'https://httpbin.org/delay/1'
]

def download_site(url):
    print(f"شروع دانلود از: {url}")
    response = requests.get(url)
    print(f"پایان دانلود: {url} با کد وضعیت {response.status_code}")
    return response.status_code

# استفاده از ThreadPoolExecutor برای مدیریت ریسمان‌ها
start_time = time.time()

with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # متد map کارهای تکراری را به صورت همزمان روی آیتم‌های لیست اجرا می‌کند
    results = executor.map(download_site, URLS)

print("nنتایج دریافت شده:")
for url, status in zip(URLS, results):
    print(f"{url} -> {status}")

end_time = time.time()
print(f"کل زمان اجرا: {end_time - start_time:.2f} ثانیه")

تحلیل کد: در حالت عادی، اجرای این کد حدود ۷ ثانیه زمان می‌برد (۲+۱+۳+۱ ثانیه). اما به لطف استفاده از ThreadPoolExecutor و اجرای همزمان، کل فرآیند تنها در حدود ۳ ثانیه (به اندازه طولانی‌ترین درخواست) به پایان می‌رسد! ویژگی max_workers مشخص می‌کند که حداکثر چند کارگر یا نخ به طور همزمان حق فعالیت دارند.

۴. کار با ProcessPoolExecutor (بهینه‌سازی محاسبات سنگین)

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

import concurrent.futures
import time

def cpu_bound_task(number):
    print(f"شروع پردازش عدد {number}")
    # شبیه‌سازی یک کار محاسباتی بسیار سنگین
    count = 0
    for i in range(10_000_000):
        count += i
    print(f"اتمام پردازش عدد {number}")
    return count

if __name__ == '__main__':
    numbers = [50, 60, 70, 80]
    start = time.time()

    # استفاده از تمام ظرفیت پردازنده با ساخت پروسس‌های موازی
    with concurrent.futures.ProcessPoolExecutor() as executor:
        results = executor.map(cpu_bound_task, numbers)
        
    print(list(results))
    print(f"کل زمان محاسبات: {time.time() - start:.2f} ثانیه")

توجه داشته باشید که کدهای مربوط به پردازش موازی حتماً باید درون شرط if __name__ == '__main__': قرار بگیرند؛ در غیر این صورت برنامه در سیستم‌عامل‌های مختلف دچار مشکل چرخه بی‌نهایت و خطاهای سیستمی می‌شود.

۵. جدول مقایسه جامع Thread و Process

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

۶. شیء Future چیست و چگونه آن را مدیریت کنیم؟

وقتی کاری را به یک مجری می‌سپارید، فوراً یک شیء از نوع Future به شما برگردانده می‌شود. این شیء در واقع یک رسید یا وعده است که به شما می‌گوید: «من این کار را در پس‌زمینه شروع کرده‌ام، هر زمان که تمام شد می‌توانی نتیجه‌اش را از من تحویل بگیری».

برخلاف متد map که نتایج را دقیقاً به همان ترتیب ورودی برمی‌گرداند، با ترکیب متد submit و تابع as_completed می‌توانید نتایج را به محض آماده شدن دریافت کنید. این کار سرعت دسترسی به خروجی‌های اولیه را در تکنیک‌های توسعه نرم‌افزار به شدت بالا می‌برد.

import concurrent.futures
import time

def process_data(name, delay):
    time.sleep(delay)
    return f"بخش {name} پردازش شد."

with concurrent.futures.ThreadPoolExecutor() as executor:
    # ثبت کارهای پس‌زمینه با متد submit
    future_to_task = {
        executor.submit(process_data, 'A', 3): 'کار اول',
        executor.submit(process_data, 'B', 1): 'کار دوم',
        executor.submit(process_data, 'C', 2): 'کار سوم'
    }

    # دریافت نتایج به محض آماده شدن (به ترتیب سرعت اتمام کارها)
    for future in concurrent.futures.as_completed(future_to_task):
        task_name = future_to_task[future]
        try:
            result = future.result()
            print(f"نتیجه {task_name}: {result}")
        except Exception as e:
            print(f"کار {task_name} با خطای مواجه شد: {e}")

خروجی این تکه کد نشان می‌دهد که کار دوم (با تاخیر ۱ ثانیه) زودتر از کار اول (با تاخیر ۳ ثانیه) چاپ می‌شود. این همزان‌سازی هوشمندانه به شما کمک می‌کند رابط کاربری یا سرویس‌های پویاتری بسازید.

۷. عیب‌یابی سریع و رفع خطاهای رایج (Troubleshooting)

هنگام توسعه کدهای چندرشته‌ای یا چندپروسسی ممکن است با چالش‌هایی روبرو شوید. در این بخش رایج‌ترین مشکلات و راهکارهای برطرف کردن آن‌ها را با هم بررسی می‌کنیم:

۸. سوالات متداول (FAQ)

در این بخش به چند سوال پرتکرار شما در زمینه مدیریت همزمانی در پایتون پاسخ می‌دهیم تا تمام ابهامات برطرف شود.

جمع‌بندی و گام‌های بعدی

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