Threads - חלק 3
פרקי ההרצאה: Threads - חלק 3
תמלול ההרצאה: Threads - חלק 3
הטקסט המלא של הדקות הראשונות בהרצאה «Threads - חלק 3» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
כאשר אנחנו מתעסקים עם טרדים יש לנו מבחינת מערכת ההפעלה מספר אזורים שבהם טרדים יכולים להיות. בואו נצייר כאן כרגע שני אזורים כאלה. האזור הזה, האזור השמאלי בציור שלנו, נקרא Runnable ו-Runnable זה בעצם טרדים שממתינים לריצה ועדיין לא רצים.
כאשר אנחנו יוצרים אובייקט טרד ואנחנו רוצים להריץ אותו אז אנחנו קוראים לפונקציית סטארט. ברגע שעשינו את זה הטרד נכנס לאזור ה-runnable.
זה בעצם המצב שבו הטרד הוא סטארטינג. בכל רגע מערכת ההפעלה לוקחת את אחד הטרדים ומעבירה אותו מהאזור של ה-runnable לאזור של ה-run time. מה זה האזור של ה-run time?
האזור של ה-run time זה אזור שבו טרד אחד מקבל זמן CPU למשך time slice. time slice זה הזמן הזה שדיברנו עליו, זמן מאוד מאוד קטן, שבו הפונקציה שהטרד מפעיל עובדת.
אבל הטרד יכול לעבוד הרבה יותר זמן מאשר ה-time slice שלו, ולכן ברגע שהוא סיים את הטיימסלייס, מערכת ההפעלה אוטומטית מחזירה אותו לסוף התור או לאזור אחר בתור לפי הפריוריטי שלו.
וכך באזור ה-runnable יושבים הרבה הרבה הרבה טרדים, ובעצם תור של טרדים שממתינים לריצה. כל רגע מערכת ההפעלה לוקחת את אחד מהם, שמה אותו בתוך ה-run time, הוא מקבל את הזמן CPU שלו, וברגע שהוא סיים את הזמן CPU הקטן שלו, הוא חוזר בחזרה לתור.
מערכת ההפעלה זוכרת בדיוק איפה הטרד עצר מבחינת הפקודה האחרונה שהוא ביצע, ופעם הבאה שהוא יקבל את הזומן CPU, אז מערכת ההפעלה תמשיך מאותה פקודה בדיוק שבה הטרד נעצר.
אז מה שקורה בפועל זה שברגע שטרד נכנס למערכת, הוא רץ בין ה-runnable runtime עשרות או מאות או אלפי פעמים, עד שכל הפונקציה שהוא הפעיל באמת מסתיימת או עד שהוא הסתיים בצורה לא טבעית וברגע שבוא נניח הוא הריץ את הפקודה האחרונה של הפונקציה שלו אז כמובן ההרצה שלו של הפקודה הזאתי כשהוא
הריץ אותה הוא היה חייב להיות ברנטיים ולכן בדיוק מפה הוא מסיים את הפקודה האחרונה שלו וזה נחשב שהוא מת וזה בעצם המחזור של טרד. קראנו לפונקציית סטארט, אחרי שיצרנו את האובייקט של הטרד והוא מצביע לנו על איזושהי פונקציה, הכנסנו אותו לתור מבחינת מערכת ההפעלה.
אף אחד לא יכול לעקוף את מערכת ההפעלה, אף אחד לא יכול לומר למערכת ההפעלה, עכשיו תתני לטרד שלי זמן CPU, זאת מערכת ההפעלה היא זאת שקובעת, אנחנו רק מכניסים את הטרד לתור.
מערכת ההפעלה לוקחת כל פעם טרד אחד, שמה אותו ב-run time, וכשהוא מסיים את הזמן CPU שלו מחזירה אותו ל-runable עד שהוא מסיים לגמרי את כל הפונקציה שלו ואז הוא מת ויוצא לגמרי מהמערכת אבל ישנו עוד אזור בואו נקרא לו נשים אותו באזור הזה והאזור הזה אפשר להוציא טרד מה-run time
לאזור הזה למשך זמן מסוים וברגע שהזמן הזה נגמר, להחזיר את הטרד לתור. האזור הזה נקרא סליפ. למה זה טוב לנו לפעמים להוציא טרד לסליפ? אם טרד לא נמצא באזור הסליפ, אלא הוא נמצא ב-runnable וכל הזמן מערכת ההפעלה נותנת לו זמן CPU ומוציאה אותו מה-run time ומחזירה אותו ל-runnable והוא משחק בין שני האזורים האלה זה נחשב שהוא זולל
לנו משאבי מערכת וזולל לנו זמן CPU ויכול להיות שלפרק זמן מסוים אנחנו בכלל לא רוצים שהוא יהיה פעיל לדוגמה אנחנו רוצים לבצע איזושהי המתנה אנחנו רוצים איזשהו delay מסוים או אנחנו אין לנו כל כך מה לעשות איתו למשך זמן מסוים יכול להיות איזושהי גרפיקה שאנחנו רוצים להזיז על המסך בטרד נפרד אבל היא אנחנו רוצים שהיא תרוץ לאט לאט וכל פעם אחרי שהיא זזה טיפה אנחנו
רוצים לבצע איזושהי המתנה איזשהו דיליי אז אם אנחנו מוציאים טרד לאזור של הסליפ אז הוא ממתין בסליפ וכשהוא בסליפ הוא לא טוחן לנו את הCPU שוב ושוב ושוב וזה הרבה יותר יעיל מבחינתנו אז איך אנחנו יכולים להוציא טרד לסליפ לצורך הדוגמה בואו נחזור בחזרה, נעתיק את כל מה שעשינו עד עכשיו, אבל בכדי שכל הדוגמאות האלה יישארו אצלכם,
בואו נפתח תוכנית חדשה לגמרי. נקרא לה Thread Slip, נדביק את כל הקוד הקודם וניפטר מכל מיני דברים שאנחנו לא באמת צריכים יותר.
לדוגמה מהCancellation Token הזה, לדוגמה נדפיס רק את הספרה אחת, בלי ה-thread name, נבצע גם כאן את הפעולה הזאת. נדפיס רק את 2.
בואו נגיד שאנחנו רצים פה עד 10, וגם פה נרוץ עד 10. נעשה את זה simple. ניקח שני אובייקטי תרד פשוטים. הנה תי אחת.
ניפטר מכל הדברים האלה שעשינו אותם רק לצורך בדיקה. יש לנו פה את תי אחת תארט, יש לנו פה את תי שתיים. נעשה לו סטארט, ואת כל היתר ניפטר.
אז בייסיקלי, איך אנחנו יכולים להוציא תרד לסליפ? אז יש כמה דרכים. דרך הראשונה שאנחנו יכולים להוציא תרד לסליפ זה על ידי הפקודה תרד.סליפ.
תרד.סליפ מקבלת מילי שניות, מילי סקנדס, בואו נניח ניתן 3 שניות ו-3,000 מילי סקנדס, ונבין מי בדיוק הולך לצאת לאזור הסליפ שראינו.
והתשובה מי הולך לצאת לאזור הסליפ היא הטרד הנוכחי. מה זה הטרד הנוכחי? הטרד הנוכחי זה הטרד שהריץ פקודה זאת. מי הריץ את הפקודה הזאת?
האם T1 הריץ את הפקודה? T2? לא ולא. מי שהריץ את הפקודה הזאת זה ה-Main Thread. אם היינו לוקחים את הפקודה הזאת ומעתיקים אותה לכאן, אז מי שהולך להריץ אותה עכשיו זה יהיה T1 והוא ייכנס לסליפ.
אם היינו לוקחים את הפקודה הזאת ושמים אותה כאן או כאן או כאן, מי שהולך להריץ אותה עכשיו יהיה T2, כי T2 הולך להריץ את טרינג' 2 ולכן הטרד T2 ייכנס לסליפ.
אבל אם אנחנו שמים אותה כאן, אז המיין הולך להריץ אותה ולכן המיין ייכנס לסליפ. אז מה שיקרה זה ש-T1 יתחיל לפעול, המיין ייכנס לסליפ להמתנה למשך שלוש שניות, ורק אחרי שלוש שניות הוא ימשיך, ייצור את T2 ויפעיל אותו.
בואו נריץ, נראה ששלוש שניות T1 מתבצע, ואחרי שלוש שניות המיין ממשיך, יוצר את T2 וממשיך לבצע את T2. בואו נראה דוגמה נוספת.
אם היינו לוקחים את הדבר הזה ושמים אותו כאן, במקום ההמתנה הזאת, לא ניקח שלוש שניות, ניקח חצי שניה.
אז מה שיקרה, זה שכל פעם פרינט אחת הולכת לבצע איזושהי הדפסה, וללכת לסליפ למשך חצי שניה. בואו נריץ, ונראה ש-T1 פחות או יותר נכנסת לסליפ כל חצי שניה.
זה מאוד דומה גם להמתנה של T2, ולכן אנחנו פחות או יותר רואים את זה אותו הדבר. אבל יכלנו גם לבצע את זה כאן. במקום ההמתנה הזאת שעשינו, עם הלולאה thread.slip נריץ ונראה ששניהם ביחד הולכים לבצע את ההדפסות כי מתבצעת הדפסה ואז שניהם ביחד כל אחד בעצמו
עף ל-slip. למה הפקודה הזאת היא הרבה יותר יעילה מהפקודה הזאת? דבר ראשון, ההמתנה עם הלולאה שעשיתי בהתחלה זה בכלל לא מדויק כי כמה זמן הלולאה הזאת מתבצעת?
בכל מחשב, עם כל מהירות אחרת, הלולאה תתבצע באופן שונה. אז אם יש ללקוח שלי מחשב מאוד מהיר, אז הלולאה הזאת ייקח לה הרבה יותר זמן להתבצע מאשר ללקוח אחר שיש לו מחשב איטי.
אז דבר ראשון, הלולאה בכלל לא מדויקת מבחינת זמנים. דבר שני, הלולאה בכלל לא מוציאה את הטרד לאזור הסליפ. הלולאה עדיין גורמת לטרד להמשיך ולבצע תחינה פה, בין ה-runable ל-run time בלי הפסקה וזה טוחן את ה-CPU של המחשב וממש ממש לא יעיל ומעיק אפילו על שאר התוכניות במחשב. זה אשכרה זה
גורם להאטה של כל המחשב אפילו אם ההאטה הזאת היא בקטנה אבל אם יש הרבה כאלה אז כמובן זה יגרום למחשב להאט ולעבוד הרבה יותר לאט. אם אנחנו מוציאים את הטרד שלנו ל-sleep הוא משחרר את ה-CPU ובכלל מערכת ההפעלה לא מתעסקת איתו בחצי שנייה הזאת שהוא נכנס לתוך הסליפ.
לכן הפקודה הזאת היא הרבה יותר מתאימה אם אנחנו רוצים לבצע איזשהו דיליי. בואו נריץ ונראה שהפעם התוכנית עובדת בדומה למה שמקודם אבל אנחנו יודעים מאחורי הקלעים שזה הרבה הרבה יותר יעיל.
אז שיטה ראשונה לזרוק טרד לסליפ זה על ידי הפקודה thread.slip והפקודה הזאתי בייסיקלי אומרת הטרד הנוכחי זה שהריץ את הפקודה נכנס לסליפ למשך המילי שניות ששלחנו לפקודה.
האפשרות הבאה בתור שיש לנו זה t1.suspend וt1.resume. suspend ו-resume זה פונקציות שנחשבות Deprecated,