Threads - חלק 5
WaitOne כדי לנעול. אם מישהו אחר נעל, הקריאה נתקעת עד שהוא משחרר. אחרי הקטע הקריטי קוראים ל-ReleaseMutex.WaitOne עד ששחררו אותה, ורק אז נכנסת לקטע הקריטי.Release משחרר כניסה נוספת, ו-WaitOne נכנס או מחכה.AcquireReaderLock לקריאה, AcquireWriterLock לכתיבה, ו-ReleaseReaderLock או ReleaseWriterLock לשחרור. לכל רכישה מעבירים זמן המתנה מקסימלי, בדוגמה 1000 מילישניות.פרקי ההרצאה: Threads - חלק 5
תמלול ההרצאה: Threads - חלק 5
הטקסט המלא של הדקות הראשונות בהרצאה «Threads - חלק 5» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
הרכיב הראשון שאנחנו הולכים לראות נקרא mutex בואו נפתח פה דוגמה נפרדת עבור mutex אוקיי אז יש לנו פה תוכנית console application פשוטה ואנחנו הולכים לבדוק את הרכיב הזה שנקרא mutex אז ראשית יש לנו כאן את המשתנה הזה בואו ניתן לו לא Initially owned false, אנחנו לא רוצים to ownership,
ואנחנו רוצים כן לתת לו איזשהו name, לא נקרא לו testing. אז יש לנו פה משתנה בולעני בשביל להגדיר איזה טרד שייך לו המיוטקס, לא מעניין אותנו כרגע לשייך את המיוטקס לטרד ספציפי, מה שמעניין אותנו ולתת לו שם.
בואו נבין מה זה אובייקט מיוטקס. מיוטקס זה אובייקט שמאפשר לבצע נעילות, שימו לב, ברמת מערכת ההפעלה. שתי הנעילות הקודמות שעשינו של המוניטור ושל הלוקינג היו ברמת האפליקציה שלנו.
כלומר, הם הגנו על איזשהו משאב משותף שבדוגמה שהראינו זה היה הליסט נמברס הזה שפתחנו כמשתנה סטטי, אבל זה היה משאב ברמת התוכנית.
קורה אם המשאב הוא בכלל קשור למערכת ההפעלה לדוגמה קובץ מסוים שאנחנו רוצים לנעול אותו על ידי מספר פרוססים שונים שיכולים להגיע לאותו הקובץ אז אנחנו יכולים לבצע נעילה ברמת מערכת ההפעלה על ידי מיוטקס וזה מתבצע על ידי השם שאנחנו נותנים למיוטקס אז ברגע שאתם פתחתם כמה מיוטקסים שונים בכל מיני תוכניות שונות אבל
נתתם להם את אותו השם ומבחינת מערכת ההפעלה זה אותו המיוטקס ולכן הוא מתייחס לאותו ריסורס. בואו נראה דוגמא. נניח שאנחנו רושמים כאן press enter for locking יש לנו פה consort read line ולצורך נעילה כל מה שאנחנו צריכים לעשות זה מיוטקס נקודה wait one.
אם אף אחד לא נעל לפני זה את המיוטקס אז יש לנו זכות לבצע את הנעילה ואנחנו ממשיכים להתקדם ל-Critical Section. אוקיי, בואו נרשום פה. Console. foreground, I'm in the Critical Section.
פה החזרנו את הצבע למצב ההתחלתי שלו. ומה שאנחנו רוצים לעשות זה לרשום למשתמש. Press Enter for Releasing. שוב פעם, Console. ReadLine בשביל להמתין. ויש לנו פה את הפונקציה שנקראת release mutex שמאפשרת לשחרר אותו, זאת אומרת כאן אנחנו מבצעים נעילה על ידי wait1 תוך כדי זה שיש לנו אפשרות להיכנס בעצמנו.
אם מישהו אחר נעל ואנחנו מנסים לבצע wait1 אנחנו כמובן נעוף לסינכרוניז ואנחנו לא נוכל להיכנס אלא אם כן הוא ישחרר. אז מי שנעל מצליח להיכנס ובסופו של דבר חייב לבצע שחרור, ברגע שהוא ביצע שחרור אנחנו יכולים להיכנס ובואו נדפיס איזושהי הודעה mute text release ונמתין.
עכשיו בואו נסתכל על משהו מעניין, איך אנחנו יכולים לראות את כל הסיפור הזה כך שנבין שהוא עובד כמו שצריך. דבר ראשון מה שאנחנו יכולים לעשות זה להריץ את התוכנית אבל על ידי קונטרול F5 כי קונטרול F5 מדמה הרצה של קובץ האקסקיושן עצמו מחוץ לוויז'ואל סטודיו.
אז אנחנו מריצים ואנחנו רואים שיש לנו פה Press Enter for Locking ואנחנו יכולים ללחוץ על Enter ואנחנו רואים שהמערכת נכנסה לקריטיקל סקשן, ביצעה אותו וממתינה שנשחרר אותה.
אבל בשלב הזה אני לא הולך לשחרר את המערכת, אני הולך לחזור לוויז'ואל סטודיו ולהריץ עוד פעם את וויז'ואל סטודיו על ידי קונטרול F5 כאילו שתוכנית אחרת רצה ומנסה להגיע לאותו המשאב.
עכשיו שימו לב למרות שהתוכנית שלנו זאת אותה התוכנית עדיין בגלל שקובץ האקסקיושן הזה רץ בצורה נפרדת אפשר להניח שזו תוכנית אחרת. אתם יכולים גם לנסות על שתי תוכניות שונות לגמרי ולראות שזה יעבוד אותו הדבר.
בתוכנית האחרת, השנייה, אני לוחץ על Enter ושימו לב שלמרות שלחצתי על Enter היא תקועה. למה היא תקועה? מפני שעוד לא שחררנו את המיוטקסט בתוכנית הראשונה ולכן התוכנית השנייה נתקעה פה ב-Wait 1 ולא הגיעה ל-Critical Faction.
כעת בואו נחזור בחזרה לתוכנית הראשונה ונלחץ בתוכנית הראשונה על Enter בכדי לשחרר את המיוטקס ותוך כדי זה שאני עושה את זה תסתכלו מה קורה בתוכנית השנייה זאת שלמעלה.
אז אני משחרר את המיוטקס ושימו לב מה קרה. לחצתי Enter בתוכנית הראשונה שתפסה את המיוטקס ושחררתי אותו וזה גרם לתוכנית השנייה להתקדם מעבר ל-Wait 1 לתפוס בעצמה את המיוטקס ולהיכנס לקריטיקל סקשן רק אחרי כמובן ששחררו אותה.
אז כאן אפשר לסיים שתי התוכניות לגמרי וזאת הייתה הדגמה איך אתם יכולים לבנות לעצמכם מעין רכיב שמבצע נעילות מבחינת מערכת ההפעלה על איזשהו ריסורס שהוא חיצוני בכלל ואנחנו רוצים להגן עליו מפני סדרה של אפליקציות שרצות במחשב.
כל אפליקציה שרוצה לגשת אליו ורוצה לטפל במצב של הנעילה הזאת, צריכה לתת את אותו ה-Name ל-MuteX, וזה מה שמגדיר למערכת ההפעלה, שזה אותו מיוטקסט, ומערכת ההפעלה מתייחסת לכל המיוטקסטים האלה כאותו רכיב שמבצע את אותה הגנה לאותו המשאב.
הרכיב הבא שאנחנו הולכים לראות גם הוא קשור למערכת ההפעלה וגם הוא נותן הוראות לרכיבים שקיימים בתוך מערכת ההפעלה. והרכיב הזה שאנחנו הולכים לראות עכשיו נקרא סמאפור והרכיב הזה בייסיקלי מאפשר למאגר של טרדים, לקבוצה של טרדים לעבוד על ריסורס אחד.
בואו ניקח פרויקט חדש, טסט סמאפור וכאן יכול להיות מצב שיש לנו בוא נניח מספר טרדים שיכולים לעבוד על משאב אחד נניח מספר טרדים שיכולים לעבוד על אותו קובץ או על שלושה קבצים שונים ואנחנו רוצים מתוך בוא נניח 100 טרדים שקיימים לנו במערכת רק לשלושה לתת אפשרות לעבוד בו זמנית אז אם מיוטקס אפשר לנו לעשות את זה על ידי טרד אחד או אם לדוגמה הלוק והמוניטור אפשרו לנו גם
כן רק לטרד אחד לעבוד על ה-critical section. כאן אנחנו יכולים לבצע עבודה של מספר טרדים. וזה באמת מתאים למקרה שיש לנו אפשרות לקחת מספר טרדים מצומצם ולהגיד להם אוקיי, לעשרה טרדים בלבד מותר לעבוד על הדאטאבייס כי יש לנו רק עשרה קונקשנים בו זמנית שיכולים להיות פתוחים לדאטאבייס מבחינת רישיון בואו נניח, אבל יותר מזה אנחנו רוצים לא לתת
גישה ושימתינו עד שיתפנה אחד לדוגמה. איך אנחנו הולכים להדגים את זה? אז בואו ניקח איזושהי לולאה שרצה מ-1 עד 6. ובואו נניח שיש לנו פה איזושהי פונקציה שמקבלת אובייקט.
בואו נניח שהיא רצה 10 פעמים ומדפיסה את האובייקט שהיא קיבלה על המסך. והיא הולכת לישון בכדי שהיא לא תבצע את זה בעל-פי את השנייה.
בואו נניח שהיא הולכת לישון למשך שנייה. כעת אנחנו רוצים בלולאה הזאת לפתוח טרדים. כל טרד מצביע על הפונקציה פרינט ואנחנו שולחים לו את ה-i.
זאת אומרת שהטרד הראשון יגרום להצגה של 10 פעמים 1, הטרד השני 10 פעמים 2, הטרד השלישי 10 פעמים 3 וכן הלאה. בואו נריץ את זה ונראה שכל פעם מוצגים לנו כל המספרים מ-1 עד 6, כך עשר פעמים.
למה כל המספרים מ-1 עד 6 מוצגים? מפני שמיד הלולאה הזאת של המיין הסתיימה, נפתחו שישה טרדים וכל השישה טרדים פועלים ביחד ולכן הפונקציה הזאת פרינט מופעלת במקביל שש פעמים כאשר כל פעם היא מדפיסה מספר אחר.
זאת הסיבה שכל הזמן אנחנו רואים כל המספרים מ-1 עד 6 מוצגים ושימו לב שאנחנו לא חייבים לראות אותם באותו הסדר. לדוגמה, כאן אנחנו רואים 1, 2, ואז 4, ואז 3, ואז 5, ואז 6.
פה אנחנו רואים 2, 1, 3, 5, 6. פה אנחנו רואים 4, 1, 2, 3, 5 וכולי. זאת אומרת, הסדר אכן הוא לא קבוע, אבל עדיין ששת הטרדים עובדים על הפונקציה הזאת.
עכשיו מה שאנחנו רוצים לעשות זה לתת הרשאה רק לבוא נניח שלושה טרדים במקביל לעבוד על הפונקציה. אם מישהו מהם מסתיים אז יכול טרד אחר להיכנס ולבצע עבודה על הפונקציה.
בואו נבדוק איך אפשר לעשות את זה. בואו ניקח משתנה static, סמאפור, נקרא לו mySemaphore ובתוך המיין נבנה אובייקט ממנו. עכשיו הקונסטרקטור שלו מקבל שני ערכים אינטג'ריים אינישיאל קאונט ומקסימום קאונט. בואו נבין מה הם על ידי זה שנפתח משתנים שיסבירו את ערכם.
הראשון ואינישיאל טרדס אלאוד, כמה טרדים בהתחלה מותר להם להיכנס ולעבוד על המשאב, בוא נגיד כשאף אחד והשני זה מקסימום טרדס אלאוד, כמה מקסימום טרדים מותר להם לעבוד על המשאב הזה.
בואו נניח שלושה. אז נשלח את ה-initial ואת המקסימום, וכעת הכנו את הקרקע עבור רכיב הסמאפור. בואו נגיד כאן console read line, בכדי שאנחנו נשלוט על מתי בעצם אנחנו מתחילים ומאפשרים את התהליך.
mySemaphore.release מקסימום טרד הלארד. זאת אומרת בנינו את האובייקט ואמרנו על ההתחלה אף טרד אסור לו להתחיל ולעבוד עד שאנחנו לא נגיד כמה טרדים אנחנו מעוניינים להתחיל ובמקסימום אנחנו רוצים שרק שלושה טרדים יוכלו לעבוד בו זמנית על המשאב שלנו בהקשר שלנו זאת הפונקציה print
ואחרי שאנחנו לוחצים על enter אנחנו אומרים טוב אנחנו משחררים שלושה טרדים שיוכלו להתחיל לעבוד על המשאב הזה וכל מה שאנחנו צריכים לעשות בפונקציה זה לבצע את ההגנות ואת הנעילות.
כאן אנחנו מבצעים המתנה ובסיום הפונקציה שחרור. wait1 בא לטרד ואומר אם אתה עדיין בעצם נמצא במצב שבו אתה יכול להיכנס ולעבור אל המשאב, כלומר אם הגדירו לי שלושה טרדים בו זמנית ורק שניים נניח עובדים ועכשיו הטרד השלישי נכנס לווייט וואן אז כמובן דגל נוסף עולה
או איזשהו קאונטר נוסף עולה בסמאפור והטרד שלנו מסוגל להיכנס. טרד מספר 4 שינסה להגיע לפונקציה ווייט וואן תחסום אותו מפני שהגדרנו שרק שלושה טרדים יכולים לעבוד בו זמנית על פונקציית הפרינט.
ברגע שטרד מסוים ייכנס ל-release הוא כמובן יחזיר חזרה קאונטר אחד ואומר שמי שממתין יוכל עכשיו להיכנס. אז הדוגמה הזאת מראה רק איך שלושה טרדים בו זמנית יכולים לעבוד על המשאב שלנו, כלומר על הפונקציה הזאת.
בואו נריץ ונסתכל מה קורה. ואנחנו רואים קודם כל שיש לנו פה המתנה עד שאנחנו לא לוחצים enter, בואו נלחץ enter, ונראה שרק שלושה טרדים הגיעו ויש להם את היכולת לעבוד על הפונקציה, זה יהיה 1, 3, 5.
אבל ברגע שהם סיימו אנחנו פתאום רואים ששתיים, ארבע ושש יכולים עכשיו לעבוד על הפונקציה. זה לא אותו המצב כמו מקודם שששת הטרדים עבדו ביחד על הפונקציה.
בואו נראה מה קורה אם אנחנו מזיזים את זה לשתיים. מה אמרנו פה? ורק שני טרדים יכולים לעבוד בו זמנית על הפונקציה שלנו.
נריץ, שמיכה center, אחד ושתיים כרגע עובדים על הפונקציה. כל הטרדים האחרים, ארבעת הטרדים האחרים ממתינים בכלל, הם תקועים ב-wait one.
עכשיו שניים אחרים יכולו להיכנס, זה יהיה ארבע ושלוש, ורק כשהם יסתיימו, השניים האחרונים יוכלו להיכנס, שזה יהיה שש וחמש.
אנחנו יכולים להגדיר שרק קבוצה מסוימת של טרדים יכולים לעבוד על ריסורס מסוים. אם כמובן מותר לקבוצה הזאת לעבוד על הריסורס, אז יכול להיות שיש לנו המון טרדים במערכת, אבל רק קבוצה מסוימת יש להם אישור לעבוד על המשאב, וזה מתבצע על ידי הסמאפור.
הרכיב הבא שאנחנו הולכים לראות זה רכיב שלפי דעתי הוא מאוד מעניין, הוא מאוד פרקטי הרכיב הזה גם כן אומר שיש לכם יכולת לעבוד בוא נניח רק עם טרד אחד ויחיד על משאב כמו מיוטקס או כמו הלוק או המוניטור אבל הרכיב הזה עושה הבדלה בין היכולת לקרוא מהמשאב לבין היכולת לכתוב אליו והרכיב הזה נקרא רידר רייטר לוק אז אני רוצה לפתוח פה פרויקט חדש בכדי להראות אותו ולצורך הדוגמה
בואו ניקח כאן איזשהו משתנה, נניח ליסט של אינט,