C Academy · Lektion

Shared Memory

Schnelle IPC

Lektion 2 von 413 Schritte

Shared Memory ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Schnelle IPC mit gemeinsam genutztem Speicher

Gemeinsam genutzter Speicher ermöglicht es mehreren Prozessen, denselben Bereich des physischen Speichers in ihre Adressräume einzublenden. Er ist die schnellste Form der IPC, da Daten nicht durch den Kernel kopiert werden.

Warum es schnell ist

Pipes und Sockets kopieren Daten aus einem Prozess in den Kernel und zurück. Gemeinsam genutzter Speicher vermeidet dies: Nach dem Einblenden lesen und schreiben Prozesse dieselben Bytes direkt, ohne Kopie pro Nachricht.

POSIX und System V

Es gibt zwei APIs:

POSIX: shm_open + mmap, dateiähnlich und modern
System V: shmget + shmat, älter und schlüsselbasiert

Für neuen Code wird POSIX im Allgemeinen bevorzugt.

Schritt 1: Objekt erstellen

shm_open erstellt oder öffnet ein benanntes Shared-Memory-Objekt und gibt einen Dateideskriptor zurück. Der Name beginnt mit einem Schrägstrich, zum Beispiel /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 */
}

Schritt 2: Größe festlegen

Ein neues Shared-Memory-Objekt hat die Länge null. Verwenden Sie ftruncate, um seine Größe vor dem Einblenden festzulegen.

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

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

Schritt 3: Einblenden

mmap blendet das Objekt in den Adressraum des Prozesses ein und gibt einen Zeiger zurück, den Sie wie gewöhnlichen Speicher verwenden.

#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 */
}

Lesen und Schreiben

Nach dem Einblenden dereferenzieren Sie einfach den Zeiger. Eine Struktur im gemeinsam genutzten Speicher ist für jeden Prozess sichtbar, der dasselbe Objekt einblendet.

#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 ist unverzichtbar

Sie müssen MAP_SHARED übergeben, damit Schreibvorgänge für andere Prozesse sichtbar sind. MAP_PRIVATE erstellt ein privates Copy-on-Write-Mapping, das andere Prozesse niemals sehen.

Synchronisierung ist Ihre Aufgabe

Gemeinsam genutzter Speicher bietet keine integrierte Synchronisierung. Ohne Koordination können zwei Prozesse Daten durch eine Race Condition beschädigen. Schützen Sie den Speicher mit Semaphoren, Mutexen oder atomaren Operationen.

Ein benanntes Semaphore verwenden

Ein benanntes POSIX-Semaphore (sem_open) koordiniert den Zugriff. Der Produzent signalisiert mit post, sobald Daten bereitstehen; der Konsument wartet mit wait, bevor er sie liest.

#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); */

Bereinigung

Geben Sie Ressourcen stets frei:

munmap, um den Bereich auszublenden
Den Deskriptor mit close schließen
shm_unlink, um das benannte Objekt zu entfernen

Andernfalls bleibt das Objekt nach dem Beenden des Prozesses in /dev/shm bestehen.

#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);
}

Schnelltest

Testen Sie Ihr Verständnis von gemeinsam genutztem Speicher.

Beantworte es in der interaktiven Lektion

Zusammenfassung

Sie haben gemeinsam genutzten Speicher, die schnellste Form der IPC, kennengelernt.

shm_open, ftruncate und anschließend mmap mit MAP_SHARED
Den Zeiger dereferenzieren, um gemeinsam genutzte Daten zu lesen und zu schreiben
Sie müssen Ihre eigene Synchronisierung hinzufügen (Semaphore)
Mit munmap, close und shm_unlink aufräumen

Kostenlos starten

Lerne C mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 39
Lektionen: 144

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Shared Memory“ kostenlos?

Ja — der vollständige Text von „Shared Memory“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Shared Memory“?

Schnelle IPC Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Shared Memory“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C Academy