'למרות שלכל שפת תכנות יש ספריות רבות למטרות ספציפיות, לספריית POSIX של C יש את המקום שלה. הוא תוכנן ליצור הרמוניזציה גדולה בין התהליכים ועוזר רבות בשימוש בריבוי הליכי שרשור בתוך התוכניות, כלומר, יצירת שרשורים מרובים וסנכרון ביצועם. בתוך המדריך הזה היום, תראה המחשה פשוטה של שימוש בסמפורות POSIX ב-C. לדוגמאות הבסיסיות של קוד C, עלינו להגדיר את המהדר שלו במערכת. אבל לפני כן, עלינו לעדכן את המערכת שכן זהו שלב חובה לביצוע חלק של קוד. לפיכך, השאילתה המוצגת בהצמדה המצורפת היא חובה כדי לעדכן ולשדרג את מערכת ההפעלה הלינוקס שלך עם כלי השירות 'apt'.
תהליך זה דרש כ-55 Kb של שטח בפלטפורמת לינוקס שלך כדי לבצע בצורה חלקה את העדכונים. אם אתה מוכן לתת כל כך הרבה מקום, הקש על 'y' כדי להמשיך. העיבוד יסתיים בעוד מספר דקות.
לאחר השדרוג המלא של המערכת, אנו הולכים להגדיר את המהדר של שפת C במערכת שלנו עם כלי השירות apt-get בפקודה 'התקן'. השתמש ב-'gcc' כמילת מפתח, וזהו.
sem_init()
סמפור חדש ייווצר כאשר יש כבר סמפור לא מזוהה ב-'s'; אחרת, הסמפור הקיים שכבר ימחק. בכל שיטה זו, 's' מייצג מופע של סמפור שנבנה, ו-Shared הוא אות או דגלון המציינים אם הסמפור עשוי להיות מופץ עם שיטת forked() או אחרת. ערך הקלט משמש כנקודת ההתחלה המוגדרת של הסמפור.
Int sem_init ( nor_t * s, int shared, unsigned value ) ;
Sem_wait()
על ידי ביצוע פעולת נעילת סמפור על הסמפור שצוין ב-'s', שיטת sem_wait() מחזיקה את הסמפור הזה. הליך ה-Sem-Wit ישמש כדי לשמור על סמפור או לתת לו לעמוד בתור. חלק מהתהליכים שעמוסים בעבר מתעוררים כאשר תהליך אחר מפעיל את sem_post().
int sem_wait ( nor_t * ס ) ;
אין פוסט()
כאשר מתקשרים ל-sem post, הערך גדל, ואז אחת מהפעולות שגובו בעבר או ממתינות מתחילה לפעול, כלומר, פותחת את הסמפור שכבר נעול.
int sem_post ( nor_t * ס ) ;
no_destroy()
סמפור ללא שם מאותחל 's' מושמד תוך שימוש בפונקציה sem destroy() .
int sem_destroy ( nor_t * ס ) ;
דוגמא
כדי להבין את הסמפורות, ניצור תחילה קובץ C ולאחר מכן נוסיף לו קוד. כדי ליצור אחד, השתמש בשאילתת 'מגע', ותמצא את הקובץ החדש בתיקיית הבית של המערכת שלך.
כעת, עליך לפתוח את קובץ ה-C הריק שלך עם איזה עורך פשוט כדי ליצור בו קוד טוב. ניסינו עד כה את עורך 'ננו', כפי שמוצג בתמונה למטה.
כפי שכולנו יודעים שכל שפות התכנות אינן יכולות לעבוד ללא ספריות, שכן ספריות אלו מחזיקות במספר רב של מחלקות, מבנים, פונקציות ואובייקטים לניצול עבור עבודת המערכת הכוללת. אז אנחנו מתחילים את תוכנית ה-C הזו עם שימוש בכמה ספריות בסיסיות וחייבות עבור ה-POSIX Semaphores.
כדי להשתמש בספריות אלו בקוד, עלינו להשתמש בתו '#' עם מילת המפתח 'include' עבור כל ספריה. כרגע, הוספנו בסך הכל 4 ספריות שחייבים להיות בתוכנית זו. אחרת, התוכנית שלנו לא תעבוד כראוי. ספריית הכותרות הראשונה 'stdio.h' היא בדרך כלל חובה בכל תוכנית C מכיוון שהיא מאפשרת לנו לבצע פעולות קלט ופלט בקוד. לכן, אנו משתמשים בו כדי להוסיף קלט בצורה חלקה ולקבל פלטים מהקוד. הספרייה השנייה בה אנו משתמשים כאן היא ה-'pthread.h' שהוא חובה לשימוש בתכנות שרשורים, כלומר ריבוי הליכי שרשור.
אנו נשתמש בספרייה זו כדי ליצור שרשורים בתוכנית. הספרייה הבאה והחשובה ביותר בקוד זה היא 'semaphore.h'. זה נוצל כדי לסנכרן בצורה חלקה את השרשורים. אחרון חביב, הספרייה היא 'unistd.h', המאפשרת לנו להשתמש בפונקציות שונות ובקבועים המוגדרים על ידי המשתמש. כעת, הכרזנו על הסמפור 's' באמצעות האובייקט המובנה 'sem_t' של ספריית הסמפור. כאן מגיעה הפונקציה המוגדרת על ידי המשתמש 'T' ללא סוג החזרה. הוא השתמש בכמה פונקציות סמפור מובנות כדי לבצע סנכרון. הפונקציה sem_wait() היא כאן כדי להחזיק את הסמפור 's' באמצעות התו '&'.
בתוך ה-hold, ההצהרה printf() בוצעה יחד עם הפונקציה 'sleep' כדי להפוך את התוכנית הזו למצב שינה למשך 4 שניות. הצהרת printf() נוספת מציגה הודעה חדשה, והפונקציה sem_post() מבוצעת כדי לשחרר את הנעילה בסמפור 's'.
#include#include
#include
#include
לא_לא s;
בָּטֵל * ט ( בָּטֵל * arg ) {
sem_wait ( & ס ) ;
printf ( 'ברוך הבא! \n ' ) ;
לִישׁוֹן ( 4 ) ;
printf ( 'ביי! \n ' ) ;
sem_post ( & ס ) ;
}
בואו נסתכל היטב על שיטת main() של תוכנית C זו עבור סמפורים. הפונקציה sem_init() נוצלה כאן כדי ליצור סמפור חדש 's' שלא הופץ בשיטת forked(), כלומר, '0', ונקודת ההתחלה שלו מוגדרת ל-1. האובייקט pthread_t מה-pthread הספרייה של C נוצלה ליצירת שני חוטים באמצעות שני אובייקטי חוט, o1 ו-o2. ההצהרה printf() כאן כדי להציג שאנו הולכים ליצור את השרשור הראשון באמצעות הפונקציה pthread_create() בשורה הבאה ממש.
העברנו את האובייקט o1 thread לפונקציה הזו עם הגבלות NULL וקראו לפונקציה 'T' על ידי העברתו בפרמטרים. לאחר שינה של 4 שניות, נוצר שרשור נוסף עם אובייקט o2, והפונקציה pthread_join() משמשת כאן כדי לחבר את השרשורים עם פונקציית main(). הפונקציה sem_destroy() כאן כדי להרוס את הסמפור 's', וכל השרשורים החסומים ישוחררו גם כן.
int main ( ) {sem_init ( & s, 0 , 1 ) ;
pthread_t o1, o2;
printf ( 'בשרשור הראשון עכשיו... \n ' ) ;
pthread_create ( & o1,NULL,T,NULL ) ;
לִישׁוֹן ( 4 ) ;
printf ( 'בשרשור 2 עכשיו... \n ' ) ;
pthread_create ( & o2,NULL,T,NULL ) ;
pthread_join ( o1, NULL ) ;
pthread_join ( o2, NULL ) ;
לא_להרוס ( & ס ) ;
לַחֲזוֹר 0 ;
}
אנו מרכיבים את תוכנית C עם המהדר 'Gcc'; האפשרויות '-lrt' ו-'-lpthread' משמשות לביצוע פונקציות השרשור של POSIX. בהפעלת השאילתה '.a/.out', נוצר השרשור הראשון. הוא עובר למצב שינה לאחר הדפסת ההודעה הראשונה.
השרשור השני הסתנכרן, ואחרי 4 שניות, השרשור הראשון השתחרר, והשרשור השני ננעל ל-4 שניות.
בסופו של דבר, גם השרשור השני שוחרר.
סיכום
זהו העניין של POSIX Semaphores ב-C תוך שימוש בכמה מהפונקציות העיקריות שלו לסנכרון שרשורים שונים. לאחר שתעבור על המאמר הזה, תוכל להבין את POSIX יותר ויותר.