0Pricing
C Academy · Lezione

Memoria condivisa

IPC veloce

Memoria condivisa è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.

IPC veloce con la memoria condivisa

La memoria condivisa consente a più processi di mappare la stessa area di memoria fisica nei propri spazi di indirizzamento. È la forma di IPC più veloce, perché i dati non vengono copiati attraverso il kernel.

Perché è veloce

Pipe e socket copiano i dati da un processo al kernel e viceversa. La memoria condivisa evita questo passaggio: una volta mappati, i processi leggono e scrivono gli stessi byte direttamente, senza una copia per ogni messaggio.

POSIX e System V

Esistono due API:

  • POSIX: shm_open + mmap, simile ai file e moderna
  • System V: shmget + shmat, più datata e basata su chiavi

In genere, per il nuovo codice si preferisce POSIX.

Passaggio 1: creare l'oggetto

shm_open crea o apre un oggetto di memoria condivisa con nome e restituisce un descrittore di file. Il nome inizia con una barra, ad esempio /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 */
}

Passaggio 2: impostare le dimensioni

Un oggetto condiviso appena creato ha lunghezza zero. Utilizzi ftruncate per impostarne le dimensioni prima della mappatura.

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

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

Passaggio 3: eseguire la mappatura

mmap mappa l'oggetto nello spazio di indirizzamento del processo e restituisce un puntatore che può utilizzare come una normale area di memoria.

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

Leggere e scrivere

Una volta eseguita la mappatura, è sufficiente dereferenziare il puntatore. Una struct nella memoria condivisa è visibile a ogni processo che mappa lo stesso oggetto.

#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 è essenziale

Deve passare MAP_SHARED affinché le scritture siano visibili agli altri processi. MAP_PRIVATE crea una mappatura privata copy-on-write, che gli altri processi non vedranno mai.

La sincronizzazione è compito Suo

La memoria condivisa non fornisce alcuna sincronizzazione integrata. Senza coordinamento, due processi possono corrompere i dati in una race condition. La protegga con semafori, mutex o operazioni atomiche.

Utilizzare un semaforo con nome

Un semaforo POSIX con nome (sem_open) coordina gli accessi. Il produttore esegue post quando i dati sono pronti; il consumatore esegue wait prima di leggerli.

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

Pulizia

Rilasci sempre le risorse:

  • munmap per annullare la mappatura dell'area
  • close per chiudere il descrittore
  • shm_unlink per rimuovere l'oggetto con nome

Altrimenti l'oggetto rimane in /dev/shm dopo l'uscita del processo.

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

Verifica rapida

Verifichi la Sua comprensione della memoria condivisa.

Riepilogo

Ha imparato a utilizzare la memoria condivisa, la forma di IPC più veloce.

  • shm_open, ftruncate, quindi mmap con MAP_SHARED
  • Dereferenzi il puntatore per leggere e scrivere i dati condivisi
  • Deve aggiungere la propria sincronizzazione (semafori)
  • Esegua la pulizia con munmap, close e shm_unlink

Domande Frequenti

La lezione «Memoria condivisa» è gratuita?

Sì — il testo completo di «Memoria condivisa» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.

Cosa imparerò in «Memoria condivisa»?

IPC veloce Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C Academy?

Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Memoria condivisa»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C Academy?

Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Pipe
  2. Memoria condivisa
  3. Code di messaggi
  4. Segnali
← Torna a C Academy