חוקי הפורום

מה זה ט'רד (thread)?



  • אתמול תפסתי את עצמי שאני מתדיין בלהט על ט'רדים והמסתעף
    ובעצם אני לא יודע באמת מה זה ט'רד?
    לכן עשיתי על זה קצת חיפושים להבין מה זה בדיוק
    ואני משער שזה יועיל כאן לעוד אנשים, אז אני מעלה את הנושא כאן לדיון.

    אמנם אני עדיין לא מבין את הכל (או יותר נכון כמעט ולא מבין)
    אבל זה מה שיצא לי לבנתיים (אשמח לתיקונים):

    כשמפעילים תוכנית במחשב, יש את התהליך הראשי הנקרא Process
    שזה בעצם מידע שנשמר בכתובת בזיכרון על הפעולה
    הוא מכיל מידע כמו הID של התהליך ,העדיפות של התהליך ,ואת כל הפקודות ששייכות לתהליך ועוד
    והמעבד עובר על הפקודות שורה אחרי שורה ומבצע אותם.

    אם יש כמה פעולות מכמה תהליכים מקבילים נוצר תור אצל המעבד ( והוא מצבע אותם לפי עדיפות).

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

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

    נ.ב.
    עכשיו אני רואה שהנושא דובר כבר בפורום הישן



  • @nigun אמר במה זה ט'רד (thread)?:

    יש את התהליך הראשי הנקרא Process
    שזה בעצם מידע שנשמר בכתובת בזיכרון על הפעולה

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

    ℹ יש הבדל השקפתי יסודי בין לינוקס לווינדוס בנושא הגדרתו של "תהליך". בווינדוס התהליך הוא ישות אבסטרקטי לעצמו שכולל בתוכו לפחות thread אחד, אבל התהליך הוא לא ה-thread בעצמו אלא הבעלים שלו. בלינוקס אין שום הבדל בין תהליך ל-thread. thread הוא רק מופע מיוחד של תהליך שמשתף כמה ממאפייניו עם תהליכים/threads אחרים. (כאן מופיע rant אופייני של לינוס טורבלדס בנושא)
    דוגמה קונקרטית להבדל הוא שבווינדוס גם תהליך בעל thread אחד יש לו 2 מזהים - מזהה התהליך - PID ומזהה ה-thread - ‏TID. לעומת זאת בלינוקס יש רק מזהה אחד, ה-PID.

    כדי להבין לאשורו את הענין של threads וההבדל בין thread לתהליך, כדאי להכיר את הענין של מיפוי ובידוד הזכרון המכונה virtual memory בלע"ז.

    מרחב הזכרון הפיזי של המחשב הוא ה-RAM. אם יש לך 2 ג"ב של ראם אז מרחב הזכרון הפיזי משתרע על פני הכתובות מ-0 עד 1073741823. ה-CPU יכול לגשת לכל בייט ממרחב זיכרון זה.

    בימים הקסומים של DOS היו תהליכים ניגשים ישירות לכתובות ב-RAM.

    זה מודל בעייתי ביותר כאשר יש ריבוי תהליכים (ב-DOS לא היו ריבוי תהליכים במובן הרגיל).

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

    כדי לאפשר את עניין ריבוי התהליכים בנוחות ובביטחון, הוחלט שבמצב רגיל ה-CPU לא ניגש ישר לכתובת זכרון בראם אלא כל גישה לזיכרון עובר תהליך מיפוי מכתובת ווירטואלי לכתובת פיזי. זה מאפשר בידוד תהליכים.

    היתרון בזה הוא שבמקום שכל תהליך יצטרך לשמור על עצמו מלדרוס על הרגליים של השני, מערכת ההפעלה פשוט יגדיר עבור התהליך מפה שבו יש לו גישה לכל מרחב הזכרון האפשרי שה-CPU תומך בו (לא משנה כמה RAM באמת יש), ומאחורי הקלעים זה ימופה לכתובות פיזיות בצורה בטוחה שתהליך לא יכול לגשת לזכרון של תהליך שני. (אני מקצר קצת בתיאור של כל הפרטים של virtual memory ו-memory protection).

    האמת היא שלמרות שלתהליך יש גישה לכל מרחב הזכרון, אבל בפועל זה מחולק ל-2 חלקים. חלק א זמין למתכנת וזה נקרא user space והחלק השני לא זמין למתכנת אלא למערכת ההפעלה (שפועל עבור התהליך בתוך ה-execution context של התהליך). זה ה-kernel space. החלק של ה-user space מבודד לכל תהליך בפני עצמו, כלומר מערכת ההפעלה ממפה את הכתובות לכל תהליך לאיזור נפרד של הראם הפיזי. החלק של הקרנל הוא אותו דבר לכל תהליך, כלומר זה ממופה על ידי מערכת ההפעלה לאותם כתובות פיזיות לכל תהליך.

    לאור הנ"ל אכתוב את יתר הערותי:

    הוא מכיל מידע כמו הID של התהליך ,העדיפות של התהליך ,ואת כל הפקודות ששייכות לתהליך ועוד

    הדברים האלו לא מאוחסנים באותו מרחב זיכרון. ה-ID ושאר המטה דאטה שקשורים לתהליך מנוהלים לגמרי על ידי מערכת ההפעלה וזה נשמר במבנה בתוך מרחב הזכרון של הקרנל, הגישה אליו למתכנת הוא רק דרך ממשקים שמערכת ההפעלה מספקת (system calls בלע"ז).
    בשונה מה"פקודות ששייכות לתהליך" (כלומר הקוד - הבינארי, לא קוד המקור - של התהליך) שזה ממופה לאיזור היוזר של התהליך.

    והמעבד עובר על הפקודות שורה אחרי שורה ומבצע אותם.

    כמובן שיש גם קפיצות ולולאות...

    אבל בשונה מהתהליך הראשי הוא יכול להתשמש במשתנים הנמצאים בט'רד השכן

    מה שנקרא שהוא משתף באותו מרחב זכרון ווירטואלי של התהליך האבא (אותו מיפוי של כתובות לוגיות לפיזיים)

    אם יש כמה פעולות מכמה תהליכים מקבילים נוצר תור אצל המעבד

    במקרה שיש רק מעבד אחד, או שיש יותר תהליכים מליבות עיבוד

    @nigun אמר במה זה ט'רד (thread)?:

    (לא יודע איך הוא מנהל את העדיפות בין הט'רדים)

    בברירת מחדל (אאל"ט) thread בתוך תהליך מנוהל על ידי ה-scheduler בדיוק כמו תהליך נפרד. ווינדוס מגדירים את ה-thread כה-"Basic scheduling unit". כלומר ניהול התור לא מתייחס בכלל לתהליכים רק ל-thread-ים.


  • תכנות

    @yossiz החכמת אותי מאד!
    תודה רבה!



  • @yossiz
    תודה רבה
    לא הבנתי בדיוק את הקטע של הכתובות
    אני הבנתי שכל כתובת וירטואלית מצביעה על כתובת של ביט אחד
    אז מה קורה אם יש לי מידע ששוקל 128 ביט
    האם יש לי כתובת אחת או 128 כתובות?

    @yossiz אמר במה זה ט'רד (thread)?:

    מה שנקרא שהוא משתף באותו מרחב זכרון ווירטואלי של התהליך האבא (אותו מיפוי של כתובות לוגיות לפיזיים)

    מה זאת אומרת מרחב ווירטואלי?
    שהמערכת הפעלה ממפה את אותם כתובות כאותה משפחה, ומאפשרת קריאה מכתובת לכתובת?


התחבר כדי לפרסם תגובה
 

אידאל מגזין

מחשבים יד שניה

מחשבי מותג נייחים וניידים, מכל הרמות.

055-6727119