C Academy · บทเรียน

ไปป์

การสื่อสารระหว่างแม่และลูก

บทเรียน 1 จาก 413 ขั้นตอน

ไปป์ เป็นบทเรียน C Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C Academy มีบทเรียนทั้งหมด 4 บทเรียน

ไปป์คืออะไร

ไปป์ คือช่องทางสื่อสารทางเดียวระหว่างกระบวนการที่เกี่ยวข้องกัน กระบวนการหนึ่งเขียนไบต์ลงไป และอีกกระบวนการอ่านไบต์ออกมา คล้ายสายพานลำเลียงข้อมูล

ตัวบอกไฟล์สองตัว

การเรียก pipe() จะเติมค่าในอาร์เรย์ที่มีสององค์ประกอบ: fd[0] คือปลายสำหรับอ่าน และ fd[1] คือปลายสำหรับเขียน ข้อมูลที่เขียนไปยัง fd[1] สามารถอ่านได้จาก fd[0]

#include <unistd.h>
#include <stdio.h>

int make_pipe(int fd[2]) {
    if (pipe(fd) < 0) { perror("pipe"); return -1; }
    /* fd[0] read end, fd[1] write end */
    return 0;
}

การทำงานร่วมกับ fork

หลังจาก fork() กระบวนการแม่และกระบวนการลูกจะแชร์ตัวบอกไฟล์ของไปป์เดียวกัน นี่คือวิธีที่กระบวนการแม่และลูกสื่อสารกัน: ฝ่ายหนึ่งเขียนและอีกฝ่ายหนึ่งอ่าน

ปิดปลายที่ไม่ได้ใช้งาน

แต่ละกระบวนการควรปิดปลายที่ตนไม่ได้ใช้ ตัวอ่านปิดปลายเขียน ส่วนตัวเขียนปิดปลายอ่าน มิฉะนั้นตัวอ่านจะไม่พบจุดสิ้นสุดของไฟล์

#include <unistd.h>

void parent_as_writer(int fd[2]) {
    close(fd[0]);              /* parent will not read */
    write(fd[1], "hello", 5);  /* parent writes */
    close(fd[1]);              /* signal EOF to reader */
}

ตัวอย่างกระบวนการแม่และลูก

กระบวนการแม่เขียนข้อความ และกระบวนการลูกอ่านข้อความนั้น แต่ละกระบวนการจะปิดปลายที่ไม่จำเป็นต้องใช้

#include <unistd.h>
#include <stdio.h>

void demo(int fd[2]) {
    if (fork() == 0) {           /* child: reader */
        close(fd[1]);
        char buf[64];
        ssize_t n = read(fd[0], buf, sizeof buf - 1);
        buf[n] = 0;
        printf("child got: %s\n", buf);
        close(fd[0]);
    } else {                     /* parent: writer */
        close(fd[0]);
        write(fd[1], "hi child", 8);
        close(fd[1]);
    }
}

การอ่านคืนค่า EOF

เมื่อปลายเขียนทั้งหมดถูกปิด read จะคืนค่า 0 เพื่อส่งสัญญาณว่าถึงจุดสิ้นสุดของไฟล์แล้ว หากยังมีปลายเขียนเปิดอยู่ ตัวอ่านจะบล็อกเพื่อรอข้อมูลเพิ่มเติมตลอดไป ซึ่งเป็นข้อผิดพลาดที่พบได้บ่อย

ความจุของไปป์และการบล็อก

ไปป์มีบัฟเฟอร์จำกัด (มักมีขนาด 64 KB) หากบัฟเฟอร์เต็ม write จะบล็อกจนกว่าตัวอ่านจะอ่านข้อมูลออก หากบัฟเฟอร์ว่าง read จะบล็อกจนกว่าจะมีข้อมูลมาถึง การควบคุมการไหลนี้ช่วยประสานการทำงานของทั้งสองกระบวนการ

การเปลี่ยนเส้นทางด้วย dup2

dup2 สามารถแทนที่อินพุตมาตรฐานหรือเอาต์พุตมาตรฐานของกระบวนการด้วยปลายของไปป์ได้ เชลล์ใช้วิธีนี้เพื่อทำงานแบบ cmd1 | cmd2 โดยเชื่อมเอาต์พุตของคำสั่งหนึ่งเข้ากับอินพุตของคำสั่งถัดไป

#include <unistd.h>

void stdout_to_pipe(int fd[2]) {
    close(fd[0]);
    dup2(fd[1], STDOUT_FILENO); /* writes to stdout go into pipe */
    close(fd[1]);
}

ไปป์ที่มีชื่อ (FIFOs)

ไปป์ทั่วไปเชื่อมโยงได้เฉพาะกระบวนการที่เกี่ยวข้องกัน ส่วนไปป์ที่มีชื่อ (FIFO) ซึ่งสร้างด้วย mkfifo จะปรากฏในระบบไฟล์ ทำให้กระบวนการที่ไม่เกี่ยวข้องกันสามารถเปิดไปป์ผ่านเส้นทางและสื่อสารกันได้

#include <sys/stat.h>

int make_fifo(const char *path) {
    return mkfifo(path, 0666); /* creates a FIFO file */
}

อันตรายจาก SIGPIPE

การเขียนลงไปป์ที่ปลายอ่านถูกปิดจะทำให้เกิด SIGPIPE ซึ่งโดยค่าเริ่มต้นจะยุติกระบวนการ คุณสามารถเพิกเฉยต่อสัญญาณนี้ หรือตรวจสอบข้อผิดพลาด EPIPE ที่ได้จาก write

ควรใช้ไปป์เมื่อใด

ไปป์เหมาะอย่างยิ่งสำหรับการส่งข้อมูลแบบต่อเนื่องทางเดียวอย่างง่ายระหว่างกระบวนการแม่กับลูก หรือสำหรับเชื่อมต่อโปรแกรมเป็นลำดับ หากต้องการสื่อสารสองทางหรือสื่อสารระหว่างกระบวนการที่ไม่เกี่ยวข้องกัน ให้พิจารณา FIFO ซ็อกเก็ต หรือหน่วยความจำที่ใช้ร่วมกัน

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับไปป์

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

คุณได้เรียนรู้การใช้ไปป์เพื่อสื่อสารระหว่างกระบวนการแม่กับลูก

pipe() ให้ค่า fd[0] (อ่าน) และ fd[1] (เขียน)
ใช้ร่วมกับ fork และปิดปลายที่ไม่ได้ใช้งาน
read จะคืนค่า 0 เมื่อถึง EOF และปลายเขียนทั้งหมดถูกปิด
FIFO เชื่อมโยงกระบวนการที่ไม่เกี่ยวข้องกัน โปรดระวัง SIGPIPE

เริ่มต้นได้ฟรี

เรียนรู้ C ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 39
บทเรียน: 144

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “ไปป์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ไปป์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ไปป์”

การสื่อสารระหว่างแม่และลูก คุณปฏิบัติ C Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “ไปป์” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C Academy นี้ได้ไหม

ได้ บทเรียน C Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ C Academy