איור 1: זרימת עבודה בסיסית של מזלג ()
במאמר זה, אני הולך להראות לך כיצד להשתמש בקריאת מערכת fork () ליצירת תהליכי ילדים ב- C. אז, נתחיל.
fork () תחביר ושווי החזרה:
התחביר של פונקציית המערכת fork () הוא כדלקמן:
pid_t מזלג(בָּטֵל);
פונקציית המערכת fork () אינה מקבלת כל טענה. הוא מחזיר מספר שלם מהסוג pid_t .
עם ההצלחה, fork () מחזיר את ה- PID של תהליך הצאצא שהוא גדול מ- 0. בתוך תהליך הצאצא, ערך ההחזרה הוא 0. אם המזלג () נכשל, הוא מחזיר -1.
מזלג פשוט () דוגמא:
להלן דוגמה פשוטה של מזלג ():
#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
intרָאשִׁי(בָּטֵל) {
pid_t pid=מזלג();
אם(pid== 0) {
printf ('ילד => PPID: %d PID: %d n',להתבאס(),חולה());
יְצִיאָה (EXIT_SUCCESS);
}
אַחֵר אם(pid> 0) {
printf ('הורה => PID: %d n',חולה());
printf (״מחכה שתהליך הילד יסתיים. n');
לַחֲכוֹת(ריק);
printf (״תהליך הילד הסתיים. n');
}
אַחֵר {
printf ('לא ניתן ליצור תהליך ילדים. n');
}
לַחֲזוֹרEXIT_SUCCESS;
}
כאן השתמשתי במזלג () כדי ליצור תהליך ילדים מהתהליך הראשי/הורי. לאחר מכן הדפסתי את ה- PID (מזהה תהליך) ו- PPID (מזהה תהליך הורה) מתהליך הילד וההורה. בתהליך ההורה המתנה (NULL) משמשת להמתנה לסיום תהליך הילד. בתהליך הילד, יציאה () משמשת לסיום תהליך הילד. כפי שאתה יכול לראות, ה- PID של תהליך האב הוא ה- PPID של תהליך הילד. אז, תהליך הילד 24738 שייך לתהליך ההורה 24731 .
תוכל גם להשתמש בפונקציות כדי להפוך את התוכנית שלך למודולרית יותר. הנה, השתמשתי processTask () ו parentTask () פונקציות עבור תהליכי הילד וההורה בהתאמה. כך משתמשים בפועל במזלג ().
#לִכלוֹל#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
בָּטֵלמשימה ילד() {
printf ('שלום עולם n');
}
בָּטֵלמשימה הורה() {
printf ('משימה עיקרית. n');
}
intרָאשִׁי(בָּטֵל) {
pid_t pid=מזלג();
אם(pid== 0) {
משימה ילד();
יְצִיאָה (EXIT_SUCCESS);
}
אַחֵר אם(pid> 0) {
לַחֲכוֹת(ריק);
משימה הורה();
}
אַחֵר {
printf ('לא ניתן ליצור תהליך ילדים'.);
}
לַחֲזוֹרEXIT_SUCCESS;
}
הפלט של התוכנית לעיל:
הפעלת תהליכי ילדים מרובים באמצעות מזלג () ולולאה:
תוכל גם להשתמש בלולאה ליצירת תהליכי ילדים רבים ככל שתצטרך. בדוגמה למטה, יצרתי 5 תהליכים של ילדים באמצעות לולאה. הדפסתי גם את ה- PID וה- PPID מתהליכי הילד.
#לִכלוֹל#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
intרָאשִׁי(בָּטֵל) {
ל(intאני= 1;אני<= 5;אני++) {
pid_t pid=מזלג();
אם(pid== 0) {
printf ('תהליך ילד => PPID =%d, PID =%d n',להתבאס(),חולה());
יְצִיאָה (0);
}
אַחֵר {
printf ('תהליך הורים => PID =%d n',חולה());
printf ('מחכה שתהליכי הילד יסתיימו ... n');
לַחֲכוֹת(ריק);
printf ('תהליך הילד הסתיים. n');
}
}
לַחֲזוֹרEXIT_SUCCESS;
}
כפי שאתה יכול לראות, מזהה תהליך ההורה זהה בכל תהליכי הילד. אז כולם שייכים לאותו הורה. הם גם מבצעים בצורה לינארית. אחד אחרי השני. שליטה בתהליכי ילדים היא משימה מתוחכמת. אם תלמד עוד על תכנות מערכת לינוקס וכיצד היא פועלת, תוכל לשלוט על זרימת התהליכים הללו בכל מקרה שתרצה.
דוגמה לחיים האמיתיים:
חישובים מתמטיים מורכבים שונים כגון md5, sha256 וכו 'יצירת חשיש דורשים כוח עיבוד רב. במקום לחשב דברים כאלה באותו תהליך כמו התוכנית הראשית, אתה יכול פשוט לחשב את החשיש על תהליך ילד ולהחזיר את החשיש לתהליך העיקרי.
בדוגמה הבאה, יצרתי קוד PIN בן 4 ספרות בתהליך ילדים ושלחתי אותו לתהליך האב, התוכנית הראשית. לאחר מכן הדפסתי משם את קוד ה- PIN.
#לִכלוֹל#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
intgetPIN() {
// השתמשו ב- PPID ו- PID כזרע
מסר (חולה() +להתבאס());
intסוֹד= 1000 + שׁוּרָה () % 9000;
לַחֲזוֹרסוֹד;
}
intרָאשִׁי(בָּטֵל) {
intfd[2];
צינור(fd);
pid_t pid=מזלג();
אם(pid> 0) {
סגור(0);
סגור(fd[1]);
לאחר(fd[0]);
intמספר סודי;
גודל_טreadBytes=לקרוא(fd[0], &מספר סודי, מידה של(מספר סודי));
printf ('מחכה ל- PIN ... n');
לַחֲכוֹת(ריק);
printf ('בייט נקרא: %ld n',readBytes);
printf ('PIN: %d n',מספר סודי);
}
אַחֵר אם(pid== 0) {
סגור(1);
סגור(fd[0]);
לאחר(fd[1]);
intסוֹד=getPIN();
לִכתוֹב(fd[1], &סוֹד, מידה של(סוֹד));
יְצִיאָה (EXIT_SUCCESS);
}
לַחֲזוֹרEXIT_SUCCESS;
}
כפי שאתה יכול לראות, בכל פעם שאני מפעיל את התוכנית, אני מקבל קוד PIN שונה בן 4 ספרות.
אז, בעצם, אתה משתמש בשיחת מערכת fork () בלינוקס. תודה שקראת מאמר זה.