תהליכון

תהליך בעל שני תהליכונים:
בצד ימין רואים את ציר הזמן.
Thread 1 מתחיל לרוץ, עד שבשלב מסוים הוא נעצר, ואז Thread 2 נכנס לפעולה ומתחיל לרוץ עד שהוא מסיים את פעולתו. לאחר מכן Thread 1 ממשיך מהנקודה בה הוא הפסיק, וממשיך לרוץ עד לסיום התוכנית.
קיימות מספר סיבות להפסקת ריצתו של Thread 1 באמצע הריצה, ביניהן: א) Thread 1 ממתין לקבלת תשובה שעלולה לארוך זמן, ובמקום לבזבז זמן המתנה המעבד מתחיל להריץ את Thread 2. ב) Thread 2 נכנס פתאום, והוא בעל עדיפות גבוהה יותר. ג) המעבד מיוזמתו קוטע את ריצתו של Thread 1, כדי לאפשר גם לתהליכים אחרים לרוץ.

תהליכון (באנגלית: Thread of execution, או בקיצור: Thread) ולעיתים חוט, פתיל ריצה או נים הוא מושג במדעי המחשב המשמש במערכות הפעלה כדי לתאר הקשר ריצה במרחב כתובות.

מערכות הפעלה מודרניות מאפשרות לנהל במסגרת ריצה של תהליך (Process) מספר תהליכונים הרצים במקביל במרחב כתובות אחד. במערכות אלו כל תהליך חדש מתחיל את ביצועו באמצעות 'תהליכון ראשי' אשר עשוי בהמשך ליצור תהליכונים נוספים. מנגנון הריצה באמצעות תהליכונים מאפשר לספק למשתמש במערכת ההפעלה מהירות תגובה ורציפות פעולה כאשר התהליך (יישום) מבצע כמה משימות במקביל.

ריצה במקביל

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

יתרונות בתכנות מבוסס תהליכונים

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

חסרונות בתכנות מבוסס ריבוי תהליכונים

• ניהול של נתונים משותפים עשוי לסבך את כתיבת התוכנית, ולהגדיל את הסיכוי לתקלות בתוכנה. דוגמה למצבים כאלה היא תחרות (Race conditions) בתוך קטע קריטי בין התהליכונים העשויה לגרום לדריסת מידע לפרקים. כדי למנוע תופעות אלו, מספקות מערכות ההפעלה ושפות התכנות כלי סנכרון כדוגמת מנעול וסמפור. כלים אלו מאפשרים לתאם את הגישה למידע על ידי התהליכונים, אך יוצרים בתורם באגים פוטנציאליים נוספים כדוגמת קיפאון (Deadlock) שבו שני תהליכונים נועלים כל אחד משאבים שהשני ממתין להם וכך לא מתקדמים לעולם, או הרעבה – כאשר אחד התהליכים הרצים לעולם לא מקבל את המשאבים הנחוצים לו.

מימושים

ניתן לממש תהליכונים ברמת הליבה (Kernel-level) או ברמת המשתמש (User-level):

• ברמת הליבה – צורה זו היא צורת המימוש הפשוטה ביותר, ובה כל תהליכון הוא ישות שמערכת ההפעלה יכולה לזמן. ב־Win32 אפשרות זו נתמכה מההתחלה. בלינוקס ספריית glibc מממשת זאת (על ידי NPTL או LinuxThreads לפני כן).
• ברמת המשתמש – כל התהליכונים של תהליך הם ישות אחת בעיני מערכת ההפעלה, שכלל אינה מודעת אליהם. בגישה זו אין צורך בתמיכה של מערכת ההפעלה. לגישה זו יתרון מבחינת הזמן המבוזבז על החלפת הקשר ומבחינת ניידות של התכנה בין מערכות הפעלה שונות, אך לא ניתן ליהנות מהאצת חומרה (ריבוי מעבדים או מעבדים שתומכים בריבוי תהליכונים – Multithreading) וכן אם תהליכון בודד מייצר פסיקה כל התהליך מפסיק לרוץ, אף אם הוא מכיל תהליכונים שמוכנים לריצה.

קישורים חיצוניים

מדיה וקבצים בנושא תהליכון בוויקישיתוף

הערך באדיבות ויקיפדיה העברית, קרדיט,
רשימת התורמים
רישיון cc-by-sa 3.0

34044632תהליכון