C Academy · Lección

Memoria compartida

IPC rápida

Memoria compartida es una lección gratuita de C Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

IPC rápida con memoria compartida

La memoria compartida permite que varios procesos asignen la misma región de memoria física en sus espacios de direcciones. Es la forma más rápida de IPC porque los datos no se copian a través del kernel.

Por qué es rápida

Las tuberías y los sockets copian los datos de un proceso al kernel y de vuelta. La memoria compartida evita este paso: una vez asignada, los procesos leen y escriben los mismos bytes directamente, sin copiar cada mensaje.

POSIX frente a System V

Existen dos API:

POSIX: shm_open + mmap, similar a un archivo y moderna
System V: shmget + shmat, más antigua y basada en claves

En general, se prefiere POSIX para el código nuevo.

Paso 1: crear el objeto

shm_open crea o abre un objeto de memoria compartida con nombre y devuelve un descriptor de archivo. El nombre comienza por una barra, como /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 */
}

Paso 2: establecer el tamaño

Un objeto compartido recién creado tiene longitud cero. Use ftruncate para establecer su tamaño antes de asignarlo.

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

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

Paso 3: asignarlo

mmap asigna el objeto al espacio de direcciones del proceso y devuelve un puntero que puede utilizar como memoria normal.

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

Lectura y escritura

Una vez realizada la asignación, solo tiene que desreferenciar el puntero. Una struct en la memoria compartida es visible para todos los procesos que asignen el mismo objeto.

#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 es esencial

Debe pasar MAP_SHARED para que las escrituras sean visibles para los demás procesos. MAP_PRIVATE proporciona una asignación privada de copia en escritura, que los demás procesos nunca pueden ver.

La sincronización es responsabilidad suya

La memoria compartida no proporciona sincronización integrada. Sin coordinación, dos procesos pueden corromper los datos en una condición de carrera. Protéjala con semáforos, mutexes o atómicos.

Usar un semáforo con nombre

Un semáforo POSIX con nombre (sem_open) coordina el acceso. El productor hace post cuando los datos están listos y el consumidor espera antes de leerlos.

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

Limpieza

Libere siempre los recursos:

munmap para desasignar la región
close para cerrar el descriptor
shm_unlink para eliminar el objeto con nombre

De lo contrario, el objeto permanece en /dev/shm después de que el proceso termine.

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

Comprobación rápida

Compruebe su comprensión de la memoria compartida.

Resumen

Ha aprendido a utilizar la memoria compartida, el mecanismo de IPC más rápido.

shm_open, ftruncate y, después, mmap con MAP_SHARED
Desreferencie el puntero para leer y escribir datos compartidos
Debe añadir su propia sincronización (semáforos)
Limpie los recursos con munmap, close y shm_unlink

Preguntas frecuentes

¿La lección «Memoria compartida» es gratis?

Sí — el texto completo de «Memoria compartida» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Memoria compartida»?

IPC rápida Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Memoria compartida»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C Academy