🚀 البرمجة متعددة الخيوط في بايثون

تعلم كيف تجعل برامجك أسرع وأكثر استجابة باستخدام البرمجة متعددة الخيوط.

import threading
import time

def worker(num):
    """Thread worker function"""
    print(f'Worker {num} starting')
    time.sleep(1)
    print(f'Worker {num} ending')

threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join() # Wait for all threads to complete

print("All workers finished.")

في هذا المثال، ننشئ 5 خيوط (threads). كل خيط ينفذ الدالة worker، والتي تطبع رسالة بداية، تنتظر ثانية واحدة، ثم تطبع رسالة نهاية. `t.start()` يبدأ تنفيذ الخيط، و `t.join()` ينتظر انتهاء الخيط قبل المتابعة. هذا يسمح بتنفيذ مهام متزامنة، مما يحسن الأداء في العمليات التي تتضمن انتظاراً (مثل I/O).

['#بايثون', '#برمجة', '#متعددة_الخيوط', '#threading', '#Python', '#multithreading', '#تطوير_البرمجيات']

🚀 تحسين أداء Python: فهم GIL

هل تساءلت يومًا لماذا قد لا تستفيد برامج Python المتعددة الخيوط (multithreaded) بشكل كامل من المعالجات متعددة النوى؟ 🤔 دعنا نتعمق في Global Interpreter Lock (GIL) وكيف يؤثر على أداء Python.

import threading
import time

def count_down(n):
    while n > 0:
        n -= 1

start_time = time.time()

# بدون GIL (نظريًا، في CPython هو موجود)
# يمكن تشغيل هذه المهام بالتوازي الحقيقي على نوى مختلفة

thread1 = threading.Thread(target=count_down, args=(10000000,))
thread2 = threading.Thread(target=count_down, args=(10000000,))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

end_time = time.time()
print(f"الوقت المستغرق: {end_time - start_time:.4f} ثانية")

# ملاحظة: في CPython، بسبب GIL، ستعمل هذه الخيوط بشكل تسلسلي غالبًا،
# مما يحد من الاستفادة من المعالجات متعددة النوى للمهام التي تستهلك وحدة المعالجة المركزية.

Global Interpreter Lock (GIL) هو آلية في CPython (التنفيذ الأكثر شيوعًا لبايثون) تمنع أكثر من خيط واحد (thread) من تنفيذ بايت كود Python في نفس الوقت داخل عملية واحدة. هذا يعني أنه حتى لو كان لديك معالج متعدد النوى، فإن خيوط Python التي تستهلك وحدة المعالجة المركزية (CPU-bound) لن تعمل بالتوازي الحقيقي. بالنسبة للمهام التي تعتمد على الإدخال/الإخراج (I/O-bound)، مثل قراءة الملفات أو طلبات الشبكة، يكون GIL أقل تأثيرًا لأنه يحرر القفل أثناء انتظار عمليات الإدخال/الإخراج.

['#Python', '#GIL', '#Programming', '#Performance', '#Multithreading', '#CPython', '#Tips', '#Tutorial']

✨ تحسين أداء Python: فهم GIL 🐍

هل تساءلت يومًا لماذا قد لا تستفيد برامج Python متعددة الخيوط (multithreaded) بشكل كامل من وحدات المعالجة المركزية (CPU) متعددة النوى؟ الجواب يكمن في Global Interpreter Lock (GIL). دعنا نتعمق!

import threading
import time

def countdown(n):
    while n > 0:
        n -= 1

start_time = time.time()
# تشغيل دالتين في خيطين منفصلين (ولكن GIL يحد من التوازي الحقيقي)
thread1 = threading.Thread(target=countdown, args=(10000000,))
thread2 = threading.Thread(target=countdown, args=(10000000,))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

end_time = time.time()
print(f"الوقت المستغرق: {end_time - start_time:.4f} ثانية")

Global Interpreter Lock (GIL) هو آلية في CPython (التطبيق الأكثر شيوعًا لبايثون) تمنع خيطًا واحدًا فقط من تنفيذ كود بايثون في كل مرة، حتى على المعالجات متعددة النوى. هذا يعني أنه بالنسبة للمهام التي تعتمد بكثافة على وحدة المعالجة المركزية (CPU-bound)، فإن استخدام الخيوط المتعددة قد لا يؤدي إلى تسريع كبير. للحصول على توازي حقيقي للمهام التي تعتمد على وحدة المعالجة المركزية، فكر في استخدام وحدات (multiprocessing) بدلاً من الخيوط (threading).

['#Python', '#GIL', '#Programming', '#CPython', '#Multithreading', '#Performance', '#Tips']

✨ تحسين أداء Python: فهم GIL 🐍

هل تساءلت يومًا لماذا قد لا تعمل برامج Python المتوازية (multithreaded) بالسرعة التي تتوقعها؟ 🤔 دعنا نلقي نظرة سريعة على Global Interpreter Lock (GIL) وكيف يؤثر على الأداء.

import threading
import time

def task(n):
    for i in range(n):
        pass

start_time = time.time()

thread1 = threading.Thread(target=task, args=(10000000,))
thread2 = threading.Thread(target=task, args=(10000000,))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

end_time = time.time()
print(f"الوقت المستغرق: {end_time - start_time:.4f} ثانية")

في CPython (التنفيذ الأكثر شيوعًا لبايثون)، يسمح GIL لخيط واحد فقط بالتحكم في مفسر بايثون في أي وقت. هذا يعني أنه حتى على المعالجات متعددة النوى، لا يمكن تشغيل خيوط بايثون بشكل متوازٍ حقيقي في نفس الوقت. هذا الكود يوضح كيف يمكن أن يكون وقت التنفيذ متشابهًا أو حتى أطول قليلاً مقارنة بتشغيل المهام بشكل تسلسلي بسبب قيود GIL.

['#Python', '#برمجة', '#تطوير', '#GIL', '#أداء', '#Multithreading']