C Academy · Aula

Memória compartilhada

IPC rápido.

Memória compartilhada é uma aula grátis de C Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.

IPC rápido com memória compartilhada

A memória compartilhada permite que vários processos mapeiem a mesma região da memória física em seus espaços de endereçamento. Ela é a forma mais rápida de IPC, pois os dados não são copiados através do kernel.

Por que é rápida

Pipes e sockets copiam os dados de um processo para o kernel e de volta. A memória compartilhada evita isso: depois de mapearem a região, os processos leem e escrevem os mesmos bytes diretamente, sem uma cópia por mensagem.

POSIX versus System V

Há duas APIs:

POSIX: shm_open + mmap, semelhante a arquivos e moderna
System V: shmget + shmat, mais antiga e baseada em chaves

Em geral, POSIX é preferível para código novo.

Etapa 1: crie o objeto

shm_open cria ou abre um objeto nomeado de memória compartilhada e retorna um descritor de arquivo. O nome começa com uma 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 */
}

Etapa 2: defina o tamanho

Um objeto compartilhado recém-criado tem comprimento zero. Use ftruncate para definir seu tamanho antes de mapeá-lo.

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

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

Etapa 3: mapeie-o

mmap mapeia o objeto no espaço de endereçamento do processo e retorna um ponteiro que você utiliza como uma memória comum.

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

Leitura e escrita

Depois de mapeá-lo, basta desreferenciar o ponteiro. Uma struct na memória compartilhada fica visível para todos os processos que mapearem o mesmo 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 é essencial

Você deve passar MAP_SHARED para que as escritas fiquem visíveis a outros processos. MAP_PRIVATE fornece um mapeamento privado com cópia na escrita, que os outros processos nunca veem.

A sincronização é responsabilidade sua

A memória compartilhada não fornece sincronização integrada. Sem coordenação, dois processos podem corromper dados em uma condição de corrida. Proteja-a com semáforos, mutexes ou operações atômicas.

Usando um semáforo nomeado

Um semáforo nomeado POSIX (sem_open) coordena o acesso. O produtor sinaliza quando os dados estão prontos; o consumidor espera antes de ler.

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

Limpeza

Sempre libere os recursos:

munmap para desfazer o mapeamento da região
close para fechar o descritor
shm_unlink para remover o objeto nomeado

Caso contrário, o objeto persistirá em /dev/shm depois que o processo terminar.

#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ção rápida

Teste sua compreensão sobre memória compartilhada.

Recapitulação

Você aprendeu sobre memória compartilhada, a forma mais rápida de IPC.

shm_open, ftruncate e, em seguida, mmap com MAP_SHARED
Desreferencie o ponteiro para ler e escrever dados compartilhados
Você precisa adicionar sua própria sincronização (semáforos)
Faça a limpeza com munmap, close e shm_unlink

Perguntas Frequentes

A aula “Memória compartilhada” é grátis?

Sim — o texto completo de “Memória compartilhada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.

O que vou aprender em “Memória compartilhada”?

IPC rápido. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C Academy?

Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Memória compartilhada”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C Academy?

Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Pipes
Memória compartilhada
Filas de mensagens
Sinais

← Voltar para C Academy