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

מה זה Mutex?

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

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

דוגמא

זה מוצג בעזרת הדוגמה הבאה,

 wait (mutex); ..... Critical Section ..... signal (mutex); 

שימוש ב-Mutex

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

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

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

היתרונות של Mutex

להלן היתרונות הבאים של המוטקס, כגון:

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

חסרונות של Mutex

Mutex יש גם כמה חסרונות, כגון:

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

מה זה סמפור?

סמפור הוא פשוט משתנה שאינו שלילי ומשותף בין שרשורים. סמפור הוא מנגנון איתות, וחוט אחר יכול לסמן חוט שמחכה על סמפור.

סמפור משתמש בשתי פעולות אטומיות,

1. המתן: פעולת ההמתנה מורידה את הערך של הארגומנט S שלה אם הוא חיובי. אם S הוא שלילי או אפס, אז לא מתבצעת פעולה.

 wait(S) { while (S<=0); s--; } < pre> <p> <strong>2. Signal for the process synchronization:</strong> The signal operation increments the value of its argument S.</p> <pre> signal(S) { S++; } </pre> <p>A semaphore either allows or reject access to the resource, depending on how it is set up.</p> <h3>Use of Semaphore</h3> <p>In the case of a single buffer, we can separate the 4 KB buffer into four buffers of 1 KB. Semaphore can be associated with these four buffers, allowing users and producers to work on different buffers simultaneously.</p> <h3>Types of Semaphore</h3> <p>Semaphore is distinguished by the operating system in two categories <strong>Counting semaphore</strong> and <strong>Binary semaphore</strong> .</p> <p> <strong>1. Counting Semaphore:</strong> The semaphore S value is initialized to the <strong>number of resources</strong> present in the system. Whenever a process wants to access the resource, it performs <strong>the wait()</strong> operation on the semaphore and <strong>decrements</strong> the semaphore value by one. When it releases the resource, it performs <strong>the signal()</strong> operation on the semaphore and <strong>increments</strong> the semaphore value by one.</p> <p>When the semaphore count goes to 0, it means the processes occupy all resources. A process needs to use a resource when the semaphore count is 0. It executes the <strong>wait()</strong> operation and gets <strong>blocked</strong> until the semaphore value becomes greater than 0.</p> <img src="//techcodeview.com/img/operating-system/67/mutex-vs-semaphore-3.webp" alt="Mutex vs Semaphore"> <p> <strong>2. Binary semaphore:</strong> The value of a semaphore ranges between <strong>0</strong> and <strong>1</strong> . It is similar to mutex lock, but mutex is a locking mechanism, whereas the semaphore is a signaling mechanism. In binary semaphore, if a process wants to access the resource, it performs <strong>the wait()</strong> operation on the semaphore and decrements the value of the semaphore from 1 to 0. When it releases the resource, it performs a <strong>signal</strong> <strong>()</strong> operation on the semaphore and increments its value to 1. Suppose the value of the semaphore is 0 and a process wants to access the resource. In that case, it performs <strong>wait()</strong> operation and block itself till the current process utilizing the resources releases the resource.</p> <img src="//techcodeview.com/img/operating-system/67/mutex-vs-semaphore-4.webp" alt="Mutex vs Semaphore"> <h3>Advantages of Semaphore</h3> <p>Here are the following advantages of semaphore, such as:</p> <ul> <li>It allows more than one thread to access the critical section.</li> <li>Semaphores are machine-independent.</li> <li>Semaphores are implemented in the machine-independent code of the microkernel.</li> <li>They do not allow multiple processes to enter the critical section.</li> <li>As there is busy and waiting in semaphore, there is never wastage of process time and resources.</li> <li>They are machine-independent, which should be run in the machine-independent code of the microkernel.</li> <li>They allow flexible management of resources.</li> </ul> <h3>Disadvantage of Semaphores</h3> <p>Semaphores also have some disadvantages, such as:</p> <ul> <li>One of the biggest limitations of a semaphore is priority inversion.</li> <li>The operating system has to keep track of all calls to wait and signal semaphore.</li> <li>Their use is never enforced, but it is by convention only.</li> <li>The Wait and Signal operations require to be executed in the correct order to avoid deadlocks in semaphore.</li> <li>Semaphore programming is a complex method, so there are chances of not achieving mutual exclusion.</li> <li>It is also not a practical method for large scale use as their use leads to loss of modularity.</li> <li>Semaphore is more prone to programmer error</li> <li>, and it may cause deadlock or violation of mutual exclusion due to programmer error.</li> </ul> <h3>Difference between Mutex and Semaphore</h3> <p>The basic difference between semaphore and mutex is that semaphore is a signalling mechanism, i.e. processes perform wait() and signal() operation to indicate whether they are acquiring or releasing the resource. In contrast, a mutex is a locking mechanism, and the process has to acquire the lock on a mutex object if it wants to acquire the resource. Here are some more differences between semaphore and mutex, such as:</p> <img src="//techcodeview.com/img/operating-system/67/mutex-vs-semaphore-5.webp" alt="Mutex vs Semaphore"> <br> <table class="table"> <tr> <th>Terms</th> <th>Mutex</th> <th>Semaphore</th> </tr> <tr> <td>Definition</td> <td>The mutex is a locking mechanism, as to acquire a resource, a process needs to lock the mutex object, and while releasing a resource process has to unlock the mutex object.</td> <td>Semaphore is a signalling mechanism as wait() and signal() operations performed on the semaphore variable indicate whether a process is acquiring or releasing the resource.</td> </tr> <tr> <td>Existence</td> <td>A mutex is an object.</td> <td>Semaphore is an integer variable.</td> </tr> <tr> <td>Function</td> <td>Mutex allows multiple program threads to access a single resource but not simultaneously.</td> <td>Semaphore allows multiple program threads to access a finite instance of resources.</td> </tr> <tr> <td>Ownership</td> <td>Mutex object lock is released only by the process that has acquired the lock on the mutex object.</td> <td>Semaphore value can be changed by any process acquiring or releasing the resource by performing wait() and signal() operation.</td> </tr> <tr> <td>Categorize</td> <td>Mutex is not categorized further.</td> <td>The semaphore can be categorized into counting semaphore and binary semaphore.</td> </tr> <tr> <td>Operation</td> <td>The mutex object is locked or unlocked by the process of requesting or releasing the resource.</td> <td>Semaphore value is modified using wait() and signal() operation apart from initialization.</td> </tr> <tr> <td>Resources Occupied</td> <td>If a mutex object is already locked, then the process desiring to acquire resource waits and get queued by the system till the resource is released and the mutex object gets unlocked.</td> <td>Suppose the process acquires all the resources, and no resource is free. In that case, the process desiring to acquire resource performs wait() operation on semaphore variable and blocks itself till the count of semaphore become greater than 0.</td> </tr> </table> <hr></=0);>

סמפור מאפשר או דוחה גישה למשאב, בהתאם לאופן ההגדרה שלו.

שימוש בסמפור

במקרה של מאגר בודד, נוכל להפריד את המאגר של 4 KB לארבעה מאגרים של 1 KB. ניתן לשייך את Semaphore לארבעה מאגרים אלו, מה שמאפשר למשתמשים ומפיקים לעבוד על מאגרים שונים בו זמנית.

סוגי סמפור

סמפור נבדלת על ידי מערכת ההפעלה בשתי קטגוריות ספירת סמפור ו סמפור בינארי .

1. ספירת סמפור: ערך הסמפור S מאותחל ל- מספר משאבים קיים במערכת. בכל פעם שתהליך רוצה לגשת למשאב, הוא מבצע ההמתנה() פעולה על הסמפור ו ירידות ערך הסמפור באחד. כאשר הוא משחרר את המשאב, הוא מבצע האות() פעולה על הסמפור ו מרווחים ערך הסמפור באחד.

כאשר ספירת הסמפור מגיעה ל-0, זה אומר שהתהליכים תופסים את כל המשאבים. תהליך צריך להשתמש במשאב כאשר ספירת הסמפור היא 0. הוא מבצע את לַחֲכוֹת() מבצע ומקבל חָסוּם עד שערך הסמפור יהיה גדול מ-0.

2. סמפור בינארי: הערך של סמפור נע בין 0 ו 1 . זה דומה לנעילת mutex, אבל mutex הוא מנגנון נעילה, בעוד שהסמפור הוא מנגנון איתות. בסמפור בינארי, אם תהליך רוצה לגשת למשאב, הוא מבצע ההמתנה() פעולה על הסמפור ומקטינה את הערך של הסמפור מ-1 ל-0. כאשר הוא משחרר את המשאב, הוא מבצע אוֹת () פעולה על הסמפור ומגדילה את הערך שלו ל-1. נניח שהערך של הסמפור הוא 0 ותהליך רוצה לגשת למשאב. במקרה כזה, הוא מבצע לַחֲכוֹת() לפעול ולחסום את עצמו עד שהתהליך הנוכחי תוך ניצול המשאבים משחרר את המשאב.

היתרונות של סמפור

להלן היתרונות הבאים של סמפור, כגון:

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

חסרון של סמפור

לסמאפור יש גם כמה חסרונות, כגון:

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

ההבדל בין Mutex לסמפור

ההבדל הבסיסי בין סמפור ל-mutex הוא שסמפור הוא מנגנון איתות, כלומר תהליכים מבצעים פעולת wait() ו-signal() כדי לציין אם הם רוכשים או משחררים את המשאב. לעומת זאת, mutex הוא מנגנון נעילה, והתהליך צריך לרכוש את המנעול על אובייקט mutex אם הוא רוצה לרכוש את המשאב. הנה עוד כמה הבדלים בין סמפור ל-mutex, כגון: