Início › Artigos › Sistemas Operacionais
Processos e memória: como o SO divide o computador
Entenda programa e processo, os estados do processo, o escalonamento Round-Robin, as threads, a hierarquia de memória e a memória virtual com paginação e swap.
Seu computador tem, talvez, quatro ou oito núcleos de processador, mas no Gerenciador de Tarefas aparecem dezenas de programas em execução: navegador, antivírus, player de música, serviços do sistema. Como tanta coisa cabe em tão poucos núcleos e em uma quantidade limitada de memória RAM? A resposta está em duas tarefas centrais do sistema operacional: o gerenciamento de processos e o gerenciamento de memória.
Neste artigo você vai aprender a diferença entre programa e processo, descobrir o que é o PID e a árvore de processos, entender os estados pelos quais um processo passa e ver como o escalonador reparte o processador com um exemplo numérico. Depois, vai conhecer a hierarquia de memória, a memória virtual com paginação e swap, e aprender a monitorar e encerrar processos no Windows e no Linux.
Programa x processo
Um programa é um arquivo no disco: uma receita de bolo escrita no papel. Ele está parado e não faz nada sozinho. Um processo é um programa em execução: a receita sendo seguida na cozinha, com ingredientes separados (memória), a etapa em que o cozinheiro está (o estado do processador) e os utensílios em uso (arquivos abertos).
Isso explica por que você pode abrir o mesmo navegador duas vezes: há um único programa no disco, mas dois processos, cada um com sua própria memória e seu próprio andamento. Cada processo reúne:
- o código do programa e os dados na memória;
- o estado do processador naquele instante (qual instrução executar em seguida);
- os arquivos e conexões abertos;
- o dono (usuário) e as permissões.
O sistema operacional guarda essas informações em uma estrutura chamada bloco de controle do processo (PCB). É por meio dela que o SO consegue pausar um processo e retomá-lo depois exatamente de onde parou.
PID e árvore de processos
Todo processo recebe um número de identificação único, o PID (Process ID). É com o PID que você manda o sistema encerrar ou observar um processo específico. Além disso, todo processo é criado por outro processo, chamado de pai. O processo criado é o filho. No Linux, o processo pai pede ao kernel uma cópia de si mesmo (chamada de sistema fork) e, em seguida, o filho pode trocar o seu código por outro programa (execve). Com isso, os processos formam uma árvore.
No topo da árvore do Linux está o processo de PID 1 (hoje, normalmente o systemd), que o kernel inicia no boot e que dá origem a todos os demais. No Windows, a raiz da árvore é o System (e o processo smss.exe inicia as sessões de usuário). Quando você abre um programa pelo menu, é o processo do ambiente gráfico que cria o processo do programa.
Estados de um processo
Durante a vida, um processo muda de situação conforme o que está acontecendo com ele. Os cinco estados do modelo clássico são:
- Novo: o processo está sendo criado.
- Pronto: tem tudo o que precisa e espera apenas pelo processador.
- Executando: está, naquele instante, usando a CPU.
- Bloqueado (ou em espera): parou porque aguarda algo, como a leitura de um arquivo, uma tecla ou um pacote de rede.
- Terminado: concluiu o trabalho e está sendo removido.
Observe as transições da figura. Um processo pronto vai para executando quando o escalonador o escolhe. Se o tempo dele acaba, volta para pronto (é a preempção). Se pede um dado do disco, vai para bloqueado e só volta para pronto quando o dado chega. Um processo bloqueado nunca vai direto para a CPU: ele precisa antes entrar na fila dos prontos.
Escalonamento: quem usa a CPU agora?
O escalonador (scheduler) é a parte do kernel que escolhe qual processo pronto recebe o processador. Em um sistema multitarefa, ele troca de processo dezenas de vezes por segundo, o que cria a ilusão de que tudo roda ao mesmo tempo. Dois algoritmos clássicos são fáceis de entender:
- Round-Robin (revezamento): cada processo recebe uma fatia de tempo fixa, chamada quantum. Se não terminar, vai para o fim da fila. É justo e simples.
- Por prioridades: processos mais importantes (como o do sistema ou o de áudio) passam na frente dos demais. O risco é a inanição: um processo de baixa prioridade que nunca consegue executar. Por isso muitos sistemas aumentam a prioridade de quem espera há muito tempo.
Exemplo numérico com Round-Robin
Considere três processos que chegam ao mesmo tempo e um quantum de 4 ms. O tempo total de CPU de cada um (o burst) é: P1 = 10 ms, P2 = 6 ms e P3 = 8 ms.
A execução acontece assim: P1 usa de 0 a 4 ms; P2, de 4 a 8; P3, de 8 a 12; P1 volta de 12 a 16; P2 termina de 16 a 18; P3 termina de 18 a 22; e P1 conclui de 22 a 24. Veja os resultados na tabela:
| Processo | Tempo de CPU | Termina em | Tempo de espera (término − CPU) |
|---|---|---|---|
| P1 | 10 ms | 24 ms | 14 ms |
| P2 | 6 ms | 18 ms | 12 ms |
| P3 | 8 ms | 22 ms | 14 ms |
| Média | 21,3 ms | 13,3 ms |
Um quantum muito pequeno aumenta a "justiça", mas gasta tempo demais com trocas de contexto (salvar e restaurar o estado de cada processo). Um quantum muito grande deixa o sistema "travado" para quem espera. Os sistemas reais buscam um meio-termo, em geral na casa de poucos milissegundos.
Threads: vários caminhos dentro de um processo
Uma thread (linha de execução) é uma sequência de instruções dentro de um processo. Um processo tem pelo menos uma thread, mas pode ter várias, que compartilham a memória e os arquivos do processo. Em um navegador, por exemplo, uma thread pode desenhar a página enquanto outra baixa imagens e uma terceira executa scripts.
Criar uma thread é bem mais barato que criar um processo, e a comunicação entre threads é mais simples, porque elas enxergam os mesmos dados. A contrapartida é que um erro em uma thread pode derrubar o processo inteiro, e é preciso cuidado para duas threads não alterarem o mesmo dado ao mesmo tempo.
Memória: RAM, cache e a hierarquia
Nem toda memória é igual. Quanto mais rápida, mais cara e menor ela é, por isso o computador usa uma hierarquia de memória: poucos bytes muito rápidos perto do processador e muitos bytes lentos mais longe.
- Registradores: dentro da CPU, acesso instantâneo, algumas dezenas de valores.
- Cache (L1, L2, L3): pequena e muito rápida, guarda o que o processador usou há pouco ou deve usar em breve.
- Memória RAM: onde ficam os programas e dados em uso. Perde o conteúdo quando o computador desliga.
- Armazenamento (SSD ou HD): grande, barato e permanente, mas muito mais lento que a RAM.
Memória virtual, paginação e swap
Se cada programa usasse endereços reais da RAM, dois programas poderiam pisar na memória um do outro, e a soma de todos nunca poderia passar do tamanho da RAM. A memória virtual resolve os dois problemas: cada processo "enxerga" um espaço de endereços só dele, e o kernel, com ajuda do hardware, traduz esses endereços virtuais para endereços físicos.
A técnica mais comum é a paginação. A memória é dividida em blocos de tamanho fixo (em geral 4 KB): as páginas (no espaço virtual) e os quadros (na RAM). Uma tabela de páginas diz em qual quadro de RAM está cada página. Quando a RAM enche, o sistema move para o disco as páginas menos usadas, na partição swap do Linux ou no arquivo de paginação do Windows, e traz de volta quando necessário. Se o processo pede uma página que não está na RAM, ocorre uma falta de página (page fault) e o kernel busca o conteúdo no disco.
Monitorando e encerrando processos
Cada sistema tem ferramentas para observar processos e memória:
| Tarefa | Linux | Windows |
|---|---|---|
| Listar processos | ps aux | Gerenciador de Tarefas, aba Processos |
| Ver uso em tempo real | top | Gerenciador de Tarefas, aba Desempenho |
| Ver memória e swap | free -h | Aba Desempenho, item Memória |
| Encerrar um processo | kill PID | Finalizar tarefa (ou taskkill) |
Quando um programa trava, primeiro tente fechá-lo normalmente. Se não responder, localize-o na lista e peça para encerrar a tarefa. No Linux, kill PID envia um pedido educado de término (sinal TERM); kill -9 PID força o encerramento imediato, sem dar chance ao programa de salvar nada, por isso deve ser o último recurso. Nunca encerre processos do sistema que você não reconhece: eles podem derrubar a sessão ou até o computador.
Pratique no laboratório
No laboratório, crie uma VM com Pinguim Linux e abra dois terminais (Ctrl+Alt+T duas vezes). No primeiro, inicie um processo que fica rodando:
python3 -m http.server 8000 # servidor web simples: ocupa o terminal
No segundo terminal, observe o processo e a memória:
ps aux | grep python3 # procure o PID do servidor (kill PID encerra)
top # tecla q para sair
free -h # RAM e swap em uso
lscpu # número de núcleos disponíveis
uptime # carga média do sistema
Anote o PID e o usuário dono do processo. Depois abra o Monitor do Sistema (Ctrl+Shift+Esc), localize o mesmo processo, encerre-o por lá e volte ao primeiro terminal: o que aconteceu? Se preferir, encerre o servidor com Ctrl+C no primeiro terminal e compare.
Resumo
- Programa é um arquivo parado; processo é um programa em execução, com memória, estado e dono próprios.
- Cada processo tem um PID e um pai; os processos formam uma árvore cuja raiz é criada pelo kernel.
- Os estados clássicos são novo, pronto, executando, bloqueado e terminado.
- O escalonador reparte a CPU; no Round-Robin, cada processo usa uma fatia (quantum) e volta ao fim da fila.
- Threads compartilham a memória do processo e são mais leves que processos.
- A hierarquia de memória vai dos registradores e caches até o disco; a memória virtual usa paginação e swap para dar a cada processo um espaço próprio.
- Use
ps,top,freeou o Gerenciador de Tarefas para monitorar e encerre processos travados com cuidado.
Teste seus conhecimentos
- Por que é possível ter dois processos do mesmo programa ao mesmo tempo? O que eles não compartilham?
- Um processo bloqueado aguardando o disco pode ir direto para o estado "executando"? Explique o caminho correto.
- No exemplo de Round-Robin do artigo, o que mudaria se o quantum fosse de 2 ms em vez de 4 ms? Cite uma vantagem e uma desvantagem.
- O que é uma falta de página e por que o excesso delas deixa o computador lento?