צינור הוא אמצעי לתקשורת בין תהליכים. תהליך אחד כותב נתונים לצינור, ותהליך אחר קורא את הנתונים מהצינור. במאמר זה נראה כיצד הפונקציה pipe () משמשת ליישום הרעיון באמצעות שפת C.
לגבי צינור
בצינור הנתונים נשמרים בסדר FIFO, כלומר כתיבת נתונים בקצה אחד של הצינור ברצף וקריאת נתונים מקצה אחר של הצינור באותו סדר רציף.
אם תהליך כלשהו קורא מהצינור, אך עדיין אין תהליך אחר שכתב לצינור, אז הקריאה מחזירה את סוף הקובץ. אם תהליך רוצה לכתוב לצינור, אך אין תהליך אחר המצורף לצינור לקריאה, זהו מצב שגיאה, והצינור יוצר אות SIGPIPE.
קובץ הכותרת
#לִכלוֹלתחביר
intצינור(intמתייצב[2])
טיעונים
פונקציה זו לוקחת ארגומנט יחיד, מערך של שני מספרים שלמים ( מתייצב ). מתייצב [0] משמש לקריאה מהצינור, ו מתגייס [1] משמש לכתיבה לצינור. התהליך שרוצה לקרוא מהצינור צריך להיסגר מתייצב [1], והתהליך שרוצה לכתוב לצינור צריך להיסגר מתייצב [0] . אם הקצוות המיותרים של הצינור אינם סגורים במפורש, סיום הקובץ (EOF) לעולם לא יוחזר.
החזר ערכים
על ההצלחה, ה צינור() מחזירה 0, לכישלון הפונקציה מחזירה -1.
מבחינה ציורית, אנו יכולים לייצג את צינור() לתפקד כדלקמן:
להלן מספר דוגמאות המתארות כיצד להשתמש בפונקציית הצינור בשפת C.
דוגמה 1
בדוגמה זו נראה כיצד פועלת פונקציית הצינור. אמנם שימוש בצינור בתהליך יחיד אינו שימושי במיוחד, אך נקבל מושג.
// דוגמה 1 ג#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
intרָאשִׁי()
{
intנ;
intמתייצב[2];
לְהַשְׁחִירבַּלָם[1025];
לְהַשְׁחִיר *הוֹדָעָה= 'שלום עולם!';
צינור(מתייצב);
לִכתוֹב(מתייצב[1],הוֹדָעָה, strlen (הוֹדָעָה));
אם ((נ=לקרוא(מתייצב[0],בַּלָם, 1024 ) ) > = 0) {
בַּלָם[נ] = 0; // לסיים את המחרוזת
printf ('קרא %d בתים מהצינור:'%ש' n',נ,בַּלָם);
}
אַחֵר
perror ('לקרוא');
יְצִיאָה (0);
}
כאן יצרנו לראשונה צינור באמצעות צינור() פונקציה ולאחר מכן נכתב לצינור באמצעות שנהב [1] סוֹף. לאחר מכן, הנתונים נקראו באמצעות הקצה השני של הצינור, כלומר מתייצב [0] . לקריאה וכתיבה לקובץ, נהגנו בעבר לקרוא() ו לִכתוֹב() פונקציות.
דוגמה 2
בדוגמה זו נראה כיצד תהליכי הורים וילדים מתקשרים באמצעות הצינור.
// דוגמה 2. ג#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
intרָאשִׁי()
{
intמתייצב[2],nbytes;
pid_t ילד ילדים;
לְהַשְׁחִירחוּט[] = 'שלום עולם! n';
לְהַשְׁחִירמאגר קריאה[80];
צינור(מתייצב);
אם((ילד ילדים=מזלג()) == -1)
{
perror ('מזלג');
יְצִיאָה (1);
}
אם(ילד ילדים== 0)
{
סגור(מתייצב[0]);// תהליך הילד אינו זקוק לקצה זה של הצינור
/ * שלח 'מחרוזת' דרך צד הפלט של הצינור */
לִכתוֹב(מתייצב[1],חוּט, ( strlen (חוּט)+1));
יְצִיאָה (0);
}
אַחֵר
{
/ * תהליך ההורה סוגר את צד הפלט של הצינור */
סגור(מתייצב[1]);// תהליך הורה אינו זקוק לקצה זה של הצינור
/ * קראו במחרוזת מהצינור */
nbytes=לקרוא(מתייצב[0],מאגר קריאה, מידה של(מאגר קריאה));
printf ('קרא מחרוזת: %s',מאגר קריאה);
}
לַחֲזוֹר(0);
}
ראשית, צינור אחד נוצר באמצעות פונקציית צינור ואז תהליך ילדים הוכשל. לאחר מכן, תהליך הילד סוגר את הקצה הנקרא וכותב לצינור. תהליך האב סוגר את קצה הכתיבה וקורא מהצינור ומציג אותו. כאן זרימת הנתונים היא רק דרך אחת שהיא מילד להורה.
סיכום:
צינור() היא קריאת מערכת עוצמתית בלינוקס. במאמר זה ראינו רק זרימת נתונים חד כיוונית, תהליך אחד כותב ותהליך אחר קורא, ויוצר שני צינורות שנוכל להשיג גם זרימת נתונים דו כיוונית.