0Pricing
C Academy · Leçon

Mémoire partagée

IPC rapide

Mémoire partagée est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.

IPC rapide avec la mémoire partagée

La mémoire partagée permet à plusieurs processus de mapper la même région de mémoire physique dans leurs espaces d'adressage. C'est la forme la plus rapide d'IPC, car les données ne sont pas copiées par le noyau.

Pourquoi est-elle rapide

Les tubes et les sockets copient les données d'un processus vers le noyau, puis les renvoient. La mémoire partagée évite cette étape : une fois la région mappée, les processus lisent et écrivent les mêmes octets directement, sans copie pour chaque message.

POSIX contre System V

Il existe deux API :

  • POSIX : shm_open + mmap, similaire aux fichiers et moderne
  • System V : shmget + shmat, plus ancien et fondé sur des clés

POSIX est généralement privilégié pour le nouveau code.

Étape 1 : créer l'objet

shm_open crée ou ouvre un objet nommé de mémoire partagée et renvoie un descripteur de fichier. Le nom commence par une barre oblique, comme /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 */
}

Étape 2 : définir sa taille

Un objet partagé nouvellement créé a une longueur nulle. Utilisez ftruncate pour définir sa taille avant de le mapper.

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

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

Étape 3 : le mapper

mmap mappe l'objet dans l'espace d'adressage du processus et renvoie un pointeur que vous utilisez comme une mémoire ordinaire.

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

Lire et écrire

Une fois la région mappée, il suffit de déréférencer le pointeur. Une structure placée dans la mémoire partagée est visible par chaque processus qui mappe le même objet.

#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 est indispensable

Vous devez transmettre MAP_SHARED pour que les écritures soient visibles par les autres processus. MAP_PRIVATE crée un mappage privé avec copie à l'écriture, que les autres processus ne voient jamais.

La synchronisation vous incombe

La mémoire partagée ne fournit aucun mécanisme de synchronisation intégré. Sans coordination, deux processus peuvent corrompre les données lors d'une condition de concurrence. Protégez-les avec des sémaphores, des mutex ou des opérations atomiques.

Utiliser un sémaphore nommé

Un sémaphore nommé POSIX (sem_open) coordonne les accès. Le producteur effectue une notification lorsque les données sont prêtes ; le consommateur attend avant de les lire.

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

Nettoyage

Libérez toujours les ressources :

  • munmap pour supprimer le mappage de la région
  • close pour fermer le descripteur
  • shm_unlink pour supprimer l'objet nommé

Sinon, l'objet persiste dans /dev/shm après la fin du processus.

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

Vérification rapide

Testez votre compréhension de la mémoire partagée.

Récapitulatif

Vous avez appris la mémoire partagée, la forme la plus rapide d'IPC.

  • shm_open, ftruncate, puis mmap avec MAP_SHARED
  • Déréférencez le pointeur pour lire et écrire les données partagées
  • Vous devez ajouter votre propre synchronisation (sémaphores)
  • Effectuez le nettoyage avec munmap, close et shm_unlink

Questions Fréquemment Posées

La leçon « Mémoire partagée » est-elle gratuite ?

Oui — le texte complet de « Mémoire partagée » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mémoire partagée » ?

IPC rapide Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C Academy ?

Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Mémoire partagée » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C Academy ?

Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Tubes
  2. Mémoire partagée
  3. Files de messages
  4. Signaux
← Retour à C Academy