C Academy · บทเรียน

หน่วยความจำร่วม

IPC ที่รวดเร็ว

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

IPC ที่รวดเร็วด้วยหน่วยความจำที่ใช้ร่วมกัน

หน่วยความจำที่ใช้ร่วมกันช่วยให้หลายกระบวนการแมปพื้นที่หน่วยความจำกายภาพเดียวกันเข้าสู่พื้นที่ที่อยู่ของตนเอง วิธีนี้เป็นรูปแบบ IPC ที่เร็วที่สุด เพราะข้อมูลไม่ต้องถูกคัดลอกผ่านเคอร์เนล

เหตุผลที่รวดเร็ว

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

POSIX เทียบกับ System V

มี API อยู่สองแบบ:

POSIX: shm_open + mmap มีลักษณะคล้ายไฟล์และทันสมัย
System V: shmget + shmat เป็นรูปแบบเก่าที่ใช้คีย์

โดยทั่วไป POSIX เป็นตัวเลือกที่แนะนำสำหรับโค้ดใหม่

ขั้นตอนที่ 1: สร้างอ็อบเจ็กต์

shm_open จะสร้างหรือเปิดอ็อบเจ็กต์หน่วยความจำที่ใช้ร่วมกันซึ่งมีชื่อ และคืนค่าตัวบอกไฟล์ ชื่อต้องขึ้นต้นด้วยเครื่องหมายทับ เช่น /myshm

#include <sys/mman.h>
#include <fcntl.h>

int create_shm(const char *name) {
    int fd = shm_open(name, O_CREAT | O_RDWR, 0666);
    return fd; /* -1 on error */
}

ขั้นตอนที่ 2: กำหนดขนาด

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

#include <unistd.h>
#include <stddef.h>

int size_shm(int fd, size_t bytes) {
    return ftruncate(fd, (off_t)bytes); /* set the region size */
}

ขั้นตอนที่ 3: แมปอ็อบเจ็กต์

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

#include <sys/mman.h>
#include <stddef.h>

void *map_shm(int fd, size_t bytes) {
    void *p = mmap(NULL, bytes, PROT_READ | PROT_WRITE,
                   MAP_SHARED, fd, 0);
    return p; /* MAP_FAILED on error */
}

การอ่านและการเขียน

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

#include <string.h>

typedef struct { int counter; char text[64]; } Shared;

void producer(Shared *s) {
    s->counter = 42;
    strcpy(s->text, "hello from producer");
}

MAP_SHARED เป็นสิ่งจำเป็น

คุณต้องส่ง MAP_SHARED เพื่อให้กระบวนการอื่นมองเห็นการเขียนได้ ส่วน MAP_PRIVATE จะสร้างการแมปส่วนตัวแบบคัดลอกเมื่อเขียน ซึ่งกระบวนการอื่นจะไม่เห็น

คุณต้องจัดการการประสานงานเอง

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

การใช้เซมาฟอร์ที่มีชื่อ

เซมาฟอร์ POSIX ที่มีชื่อ (sem_open) ใช้ประสานการเข้าถึง ผู้ผลิตจะโพสต์เมื่อข้อมูลพร้อม และผู้บริโภคจะรอก่อนอ่านข้อมูล

#include <semaphore.h>
#include <fcntl.h>

sem_t *open_sem(const char *name) {
    return sem_open(name, O_CREAT, 0666, 0); /* initial value 0 */
}
/* producer: sem_post(s);   consumer: sem_wait(s); */

การล้างทรัพยากร

ปล่อยทรัพยากรเสมอ:

munmap เพื่อยกเลิกการแมปพื้นที่
close ตัวบอกไฟล์
shm_unlink เพื่อนำอ็อบเจ็กต์ที่มีชื่อออก

มิฉะนั้นอ็อบเจ็กต์จะยังคงอยู่ใน /dev/shm หลังจากกระบวนการสิ้นสุด

#include <sys/mman.h>
#include <unistd.h>
#include <stddef.h>

void cleanup(void *p, size_t bytes, int fd, const char *name) {
    munmap(p, bytes);
    close(fd);
    shm_unlink(name);
}

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

ทดสอบความเข้าใจของคุณเกี่ยวกับหน่วยความจำที่ใช้ร่วมกัน

สรุปทบทวน

คุณได้เรียนรู้เกี่ยวกับหน่วยความจำที่ใช้ร่วมกัน ซึ่งเป็น IPC ที่เร็วที่สุด

shm_open, ftruncate จากนั้นใช้ mmap พร้อม MAP_SHARED
ดึงค่าจากตัวชี้เพื่ออ่านและเขียนข้อมูลที่ใช้ร่วมกัน
คุณต้องเพิ่มการประสานงานของตนเอง (เซมาฟอร์)
ล้างทรัพยากรด้วย munmap, close และ shm_unlink

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

บทเรียน “หน่วยความจำร่วม” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “หน่วยความจำร่วม”

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

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

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

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

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

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

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

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

ไปป์
หน่วยความจำร่วม
คิวข้อความ
สัญญาณ

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