etecanos Abrir laboratório

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:

  1. Novo: o processo está sendo criado.
  2. Pronto: tem tudo o que precisa e espera apenas pelo processador.
  3. Executando: está, naquele instante, usando a CPU.
  4. Bloqueado (ou em espera): parou porque aguarda algo, como a leitura de um arquivo, uma tecla ou um pacote de rede.
  5. Terminado: concluiu o trabalho e está sendo removido.
Diagrama de estados de um processo: novo, pronto, executando, bloqueado e terminado, com as transições entre eles
Figura 1 — Diagrama de estados de um processo: novo, pronto, executando, bloqueado e terminado, com as transições entre eles

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.

Linha do tempo do Round-Robin com quantum de 4 ms para os processos P1, P2 e P3
Figura 2 — Linha do tempo do Round-Robin com quantum de 4 ms para os processos P1, P2 e P3

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:

ProcessoTempo de CPUTermina emTempo de espera (término − CPU)
P110 ms24 ms14 ms
P26 ms18 ms12 ms
P38 ms22 ms14 ms
Média21,3 ms13,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.
Pirâmide da hierarquia de memória e a paginação da memória virtual com a área de swap no disco
Figura 3 — Pirâmide da hierarquia de memória e a paginação da memória virtual com a área de swap no disco

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:

TarefaLinuxWindows
Listar processosps auxGerenciador de Tarefas, aba Processos
Ver uso em tempo realtopGerenciador de Tarefas, aba Desempenho
Ver memória e swapfree -hAba Desempenho, item Memória
Encerrar um processokill PIDFinalizar 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, free ou o Gerenciador de Tarefas para monitorar e encerre processos travados com cuidado.

Teste seus conhecimentos

  1. Por que é possível ter dois processos do mesmo programa ao mesmo tempo? O que eles não compartilham?
  2. Um processo bloqueado aguardando o disco pode ir direto para o estado "executando"? Explique o caminho correto.
  3. 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.
  4. O que é uma falta de página e por que o excesso delas deixa o computador lento?

Continue estudando