C++ ידועה כאחת משפות התכנות המהירות ביותר עם ביצועים טובים, דיוק גבוה ומערכת ניהול זיכרון נאותה. שפת תכנות זו תומכת גם בביצוע במקביל של שרשורים מרובים עם שיתוף של משאבים מרובים ביניהם. בריבוי שרשורים, השרשור מיועד רק לבצע את פעולת הקריאה שאינה עושה בעיות מכיוון שהשרשור אינו מושפע ממה שהשרשורים האחרים עושים באותו זמן. אבל אם השרשורים האלה היו צריכים לחלוק את המשאבים ביניהם, שרשור אחד יכול לשנות את הנתונים באותו זמן מה שגורם לבעיה. כדי להתמודד עם בעיה זו, יש לנו את ה-C++ 'Mutex' שמונע גישה של משאבים מרובים לקוד/אובייקט שלנו על ידי מתן הסנכרון הקובע שניתן לספק את הגישה לאובייקט/קוד רק לשרשור אחד בו-זמנית, כך שמספר שרשורים לא יוכלו לגשת לאובייקט זה בו זמנית.
תהליך:
נכיר כיצד נוכל לעצור את הגישה של מספר שרשורים לאובייקט בו זמנית באמצעות נעילה של mutex. נדבר על התחביר של הנעילה של mutex, מה זה Multiple threading וכיצד נוכל להתמודד עם הבעיות שנגרמות מהשרשור מרובה באמצעות נעילת mutex. לאחר מכן, ניקח דוגמה של השרשור המרובה וניישם עליהם את נעילת ה-mutex.
תחביר:
אם ברצוננו ללמוד כיצד נוכל ליישם את נעילת mutex כך שנוכל למנוע גישה של שרשורים מרובים בו זמנית אל האובייקט או הקוד שלנו, אנו עשויים להשתמש בתחביר הבא:
$ std :: מנעול mut_x
$mut_x. לנעול ( ) ;
בטל func_name ( ) {
$ // קוד שאנו רוצים להסתיר מהשרשורים המרובים ייכתב כאן
$mut_x. פותח ( ) ;
}
כעת נשתמש בתחביר זה בדוגמה של הדמה ובקוד הפסאודו (שאיננו יכולים פשוט להריץ כפי שהוא בעורך הקוד) כדי ליידע אותך כיצד אנו יכולים להשתמש בדיוק בתחביר זה כפי שהוזכר בהמשך:
$ std :: מנעול mut_x
חסימה בטל ( ) {
$mut_x. לנעול ( ) ;
$ std :: cout << 'שלום' ;
$mut_x. פותח ( ) ;
}
דוגמא:
בדוגמה זו, בוא ננסה ליצור תחילה את פעולת ה-multithread ולאחר מכן להקיף את הפעולה הזו בנעילה וביטול נעילה של mutex כדי לספק את הסנכרון של הפעולה לקוד או לאובייקט שנוצרו. Mutex עוסק בתנאי גזע שהם הערכים שהם די בלתי צפויים והם תלויים בהחלפת החוטים שהם מודעים לזמן. כדי ליישם את הדוגמה עבור mutex, ראשית עלינו לייבא את הספריות החשובות והנדרשות מהמאגרים. הספריות הנדרשות הן:
$ # include
$ # include
$ # include
ספריית 'iostream' מספקת לנו פונקציה להציג את הנתונים כ-Cout, לקרוא את הנתונים כ-Cin ולסיים את ההצהרה כ-endl. אנו משתמשים בספריית 'פתיל' כדי להשתמש בתוכניות או בפונקציות מהשרשורים. ספריית 'mutex' מאפשרת לנו ליישם הן את הנעילה והן את הנעילה של mutex בקוד. אנו משתמשים ב-'# include' מכיוון שזה מאפשר את כל התוכניות הקשורות לספרייה הכלולה בקוד.
כעת, לאחר ביצוע השלב הקודם, אנו מגדירים את מחלקת mutex או משתנה גלובלי עבור ה-mutex באמצעות ה-std. לאחר מכן, אנו יוצרים פונקציה עבור נעילה וביטול נעילה של mutex שנוכל להתקשר לאחר מכן בקוד. בדוגמה זו, אנו קוראים לפונקציה זו בלוק. בגוף פונקציית הבלוק, אנו קוראים תחילה ל-'mutex.lock()' ומתחילים לכתוב את ההיגיון של הקוד.
ה-mutex.lock() מונע את הגישה של השרשורים האחרים להגיע לאובייקט או לקוד שנוצרו כך שרק שרשור אחד יכול לקרוא את האובייקט שלנו בו-זמנית. בלוגיקה, אנו מריצים לולאת for שפועלת על האינדקס מ-0 עד 9. אנו מציגים את הערכים בלולאה. ברגע שהלוגיקה הזו נוצרת בנעילת mutex לאחר ביצוע פעולתו או לאחר יציאה מהלוגיקה, אנו קוראים לשיטת 'mutex.unlock()'. קריאת שיטה זו מאפשרת לנו לבטל את נעילת האובייקט שנוצר מנעילת mutex מכיוון שהגישה של האובייקט לשרשור בודד אחד ניתנה קודם לכן וברגע שהפעולה על האובייקט נעשית על ידי חוט אחד בו-זמנית. כעת אנו רוצים שהשרשורים האחרים יגשו גם לאובייקט או לקוד הזה. אחרת, הקוד שלנו נע במצב 'מבוי סתום' שגורם לאובייקט שנוצר עם המוטקס להישאר במצב נעול לנצח ואף חוט אחר לא יוכל לגשת לאובייקט הזה. לפיכך, פעולה לא שלמה ממשיכה להתבצע. לאחר מכן, אנו יוצאים מפונקציית הבלוק ונעבור למרכזית.
בעיקרון, אנו פשוט מציגים את המוטקס שנוצר שלנו על ידי יצירת שלושת השרשורים באמצעות 'std :: thread thread_name (קורא לפונקציית הבלוק שכבר נוצרה כאן בה יצרנו את המוטקס)' עם השמות thread1, thread2 ו-thread3 וכו' בדרך זו נוצרים שלושת השרשורים. לאחר מכן אנו מצטרפים לשלושת השרשורים הללו שיבוצעו בו זמנית על ידי קריאה ל-'thread_name. שיטת join ()'. ואז, נחזיר את הערך שווה לאפס. ההסבר שהוזכר לעיל של הדוגמה מיושם בצורה של הקוד שניתן להציג באיור הבא:
בפלט של הקוד, נוכל לראות את הביצוע והתצוגה של כל שלושת השרשורים בזה אחר זה. אנו יכולים לראות גם אם האפליקציה שלנו נופלת תחת הקטגוריה של ריבוי הליכים. ובכל זאת, אף אחד מהשרשורים לא דרס או שינה את הנתונים ושיתף את המשאב שהשתנה בגלל הטמעת המוטקס של 'גוש הפונקציות'.
סיכום
מדריך זה נותן הסבר מפורט על הרעיון של פונקציית mutex המשמשת ב-C++. דנו מהן יישומי ריבוי ההליכים, באילו בעיות אנו נתקלים ביישומי ריבוי ההליכים, ומדוע עלינו ליישם את ה-mutex עבור יישומי ריבוי ההליכים. לאחר מכן דנו בתחביר של המוטקס עם דוגמה הדמה באמצעות הפסאודו-קוד. לאחר מכן, יישמנו דוגמה מלאה על יישומי ריבוי ההליכים עם ה-mutex ב-C++ Visual Studio.