C Academy · Aula

Sinais

Notificações assíncronas.

Sinais é uma aula grátis de C Academy no CoddyKit. Esta é a aula 4 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.

O que é um sinal

Um sinal é uma notificação assíncrona enviada a um processo para informar que ocorreu um evento, como um usuário pressionar Ctrl-C ou um processo filho terminar. Sinais são uma forma leve de IPC.

Sinais comuns

Alguns sinais que você encontrará com frequência:

SIGINT interrupção (Ctrl-C)
SIGTERM solicitação educada de término
SIGKILL encerramento forçado (não pode ser capturado)
SIGCHLD um filho mudou de estado
SIGSEGV acesso inválido à memória

Disposições padrão

Cada sinal tem uma ação padrão: terminar, terminar com despejo do núcleo, ignorar, parar ou continuar. Você pode substituir a maioria delas por um handler.

Instalando um handler

A forma moderna e portável de definir um handler é sigaction. O handler é uma função que recebe o número do sinal.

#include <signal.h>
#include <stdio.h>

void on_signal(int sig) {
    /* note: printf is not async-signal-safe; for demo only */
    write(1, "caught\n", 7);
}

int install(void) {
    struct sigaction sa = {0};
    sa.sa_handler = on_signal;
    return sigaction(SIGINT, &sa, NULL);
}

Por que não usar signal()

A função antiga signal() tem comportamento inconsistente entre sistemas (redefinição do handler e ausência de controle sobre SA_RESTART). Prefira sigaction, que tem comportamento bem definido e é portável.

Funções seguras para sinais assíncronos

Um handler pode interromper seu código a qualquer momento, portanto só pode chamar funções seguras para sinais assíncronos, como write. Chamar printf ou malloc de um handler pode causar um deadlock ou corrupção.

Usando uma flag volatile

Um padrão seguro: o handler define uma flag volatile sig_atomic_t, e o loop principal a verifica. Isso mantém o handler pequeno e seguro.

#include <signal.h>

volatile sig_atomic_t stop = 0;

void handler(int sig) {
    stop = 1; /* only set a flag */
}
/* main loop: while (!stop) { do_work(); } */

Enviando sinais

Use kill(pid, sig) para enviar um sinal a outro processo ou raise(sig) para enviar um sinal a si mesmo. Apesar do nome, kill envia qualquer sinal, não apenas sinais letais.

#include <signal.h>

int notify(int pid) {
    return kill(pid, SIGTERM); /* ask process to terminate */
}

Bloqueando sinais

Para proteger uma seção crítica, bloqueie temporariamente os sinais com sigprocmask e um conjunto de sinais. Os sinais bloqueados permanecem pendentes e são entregues assim que deixam de estar bloqueados.

#include <signal.h>

void block_int(void) {
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    sigprocmask(SIG_BLOCK, &set, NULL);
}

Recolhendo processos filhos com SIGCHLD

Quando um processo filho termina, o kernel envia SIGCHLD. Um handler que chama waitpid recolhe o processo filho, impedindo processos zumbis que permaneceriam na tabela de processos.

#include <signal.h>
#include <sys/wait.h>

void reap(int sig) {
    while (waitpid(-1, NULL, WNOHANG) > 0)
        ; /* reap all finished children */
}

Sinais que não podem ser capturados

Dois sinais são absolutos: SIGKILL sempre termina o processo e SIGSTOP sempre o interrompe. Eles não podem ser capturados, bloqueados ou ignorados, oferecendo ao sistema uma forma garantida de controlar processos.

Verificação rápida

Teste sua compreensão sobre sinais.

Recapitulação

Você aprendeu sobre sinais para notificações assíncronas.

Instale handlers com sigaction, não com o antigo signal
Os handlers devem ser seguros para sinais assíncronos; prefira definir uma flag
Envie sinais com kill/raise; bloqueie-os com sigprocmask
Recolha processos filhos ao receber SIGCHLD; SIGKILL e SIGSTOP não podem ser capturados

Perguntas Frequentes

A aula “Sinais” é grátis?

Sim — o texto completo de “Sinais” é 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 “Sinais”?

Notificações assíncronas. 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 4 de 4.

Quanto tempo leva a aula “Sinais”?

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

← Voltar para C Academy