מקביליות היא אחת הדרכים לשפר ביצועים של תוכנות על ידי הרצת משימות במקביל. בפוסט הזה נלמד מתי נכון להשתמש ב־שרשורים (Threads) בפייתון, ונראה דוגמאות מעשיות כולל השוואה בין תכנית חד-שרשורית לבין תכנית מרובת שרשורים.

🔁 תהליך, שרשור, ודמון – מושגים בסיסיים

• Process (תהליך) – מופע של תוכנה שרצה בזיכרון.
• Thread (שרשור) – יחידת ביצוע בתוך תהליך. תהליך אחד יכול להכיל מספר שרשורים.
• Daemon Thread (שרשור דמון) – שרשור שרץ ברקע, ומסתיים אוטומטית כשהתהליך הראשי מסתיים.

🧠 מתי נשתמש ב־Threading?

שרשורים בפייתון מתאימים במיוחד למשימות הקשורות ל־קלט/פלט (I/O) – לדוגמה:

• שליחת בקשות רשת
• עבודה עם מסדי נתונים
• קריאה/כתיבה לקבצים

אם יש לכם קוד "כבד" חישובית – ייתכן ש־multiprocessing תהיה בחירה טובה יותר. כאן אנחנו מתמקדים ב־threading.

📝 תכנית חד-שרשורית – עיבוד קבצים אחד אחרי השני

from time import perf_counter

def replace(filename, substr, new_substr):
    print(f'עובדים על הקובץ {filename}')
    with open(filename, 'r') as f:
        content = f.read()
    content = content.replace(substr, new_substr)
    with open(filename, 'w') as f:
        f.write(content)

def main():
    filenames = [
        'c:/temp/test1.txt',
        'c:/temp/test2.txt',
        'c:/temp/test3.txt',
        'c:/temp/test4.txt',
        'c:/temp/test5.txt',
        'c:/temp/test6.txt',
        'c:/temp/test7.txt',
        'c:/temp/test8.txt',
        'c:/temp/test9.txt',
        'c:/temp/test10.txt',
    ]
    for filename in filenames:
        replace(filename, 'ids', 'id')

if __name__ == "__main__":
    start_time = perf_counter()
    main()
    end_time = perf_counter()
    print(f'העיבוד לקח {end_time - start_time:.2f} שניות.')

🚀 תכנית מרובת שרשורים – עיבוד קבצים במקביל

from threading import Thread
from time import perf_counter

def replace(filename, substr, new_substr):
    print(f'עובדים על הקובץ {filename}')
    with open(filename, 'r') as f:
        content = f.read()
    content = content.replace(substr, new_substr)
    with open(filename, 'w') as f:
        f.write(content)

def main():
    filenames = [
        'c:/temp/test1.txt',
        'c:/temp/test2.txt',
        'c:/temp/test3.txt',
        'c:/temp/test4.txt',
        'c:/temp/test5.txt',
        'c:/temp/test6.txt',
        'c:/temp/test7.txt',
        'c:/temp/test8.txt',
        'c:/temp/test9.txt',
        'c:/temp/test10.txt',
    ]

    threads = [Thread(target=replace, args=(filename, 'id', 'ids')) for filename in filenames]

    for thread in threads:
        thread.start()

    for thread in threads:
        thread.join()

if __name__ == "__main__":
    start_time = perf_counter()
    main()
    end_time = perf_counter()
    print(f'העיבוד לקח {end_time - start_time:.2f} שניות.')

📌 שימו לב: בעבודה עם קבצים – ודאו שאין התנגשויות גישה לקובץ כדי למנוע תקלות כתיבה.

📦 שימוש ב־Queue לעבודה בטוחה בין שרשורים

כדי להעביר מידע בין שרשורים בצורה בטוחה, נשתמש במחלקת Queue. דוגמה קלאסית – מפיק וצרכן:

import time
from queue import Empty, Queue
from threading import Thread

def producer(queue):
    for i in range(1, 6):
        print(f'מכניסים את הפריט {i} לתור')
        time.sleep(1)
        queue.put(i)

def consumer(queue):
    while True:
        try:
            item = queue.get()
        except Empty:
            continue
        else:
            print(f'מעבדים את הפריט {item}')
            time.sleep(2)
            queue.task_done()

def main():
    queue = Queue()

    producer_thread = Thread(target=producer, args=(queue,))
    producer_thread.start()

    consumer_thread = Thread(target=consumer, args=(queue,), daemon=True)
    consumer_thread.start()

    producer_thread.join()
    queue.join()

if __name__ == '__main__':
    main()

🧩 לסיכום

• אם אתם עובדים עם קלט/פלט – שרשורים יכולים לשפר ביצועים משמעותית.
• השתמשו ב־Thread ו־Queue כשיש צורך להריץ משימות במקביל בבטחה.
• היזהרו משימוש ב־threads לחישובים כבדים – פייתון מוגבל ב־GIL (נעול גלובלי) ולכן עדיף תהליכים (multiprocessing) למקרים כאלה.