O sistema operacional

O gerente da fábrica

Pense num gerente de fábrica que coordena vários operários (processos) compartilhando uma única máquina (CPU). Ele dá a cada operário um intervalo de tempo para trabalhar, salva o estado de cada um quando o tempo acaba, e chama o próximo. Ninguém monopoliza a máquina — todos têm a sensação de estar rodando simultaneamente.

O SO também protege os processos uns dos outros: um programa com bug não pode sobrescrever a memória de outro. Cada processo acredita que tem o computador inteiro para si — mas é ilusão gerenciada pelo SO.

Escalonamento Round-Robin

Veja como o SO divide o tempo de CPU entre 4 processos. Cada processo recebe um quantum de 2 ticks e depois cede a vez ao próximo. Clique em Iniciar e observe a linha do tempo.

Note que nenhum processo fica bloqueado por muito tempo — é isso que mantém a interface responsiva enquanto você tem vários programas abertos.

O que o SO gerencia

• Processos: cada programa em execução é um processo com seu próprio espaço de memória, registradores salvos e prioridade.
• Threads: múltiplos fluxos de execução dentro de um mesmo processo, compartilhando memória.
• Memória virtual: cada processo acredita ter acesso ao espaço de memória inteiro — o SO mapeia endereços virtuais para RAM física.
• Sistema de arquivos: organiza o armazenamento em arquivos e diretórios.
• Drivers: código que faz o SO conversar com hardware específico (impressora, placa de rede...).

Algoritmos de escalonamento

# Round-Robin com quantum = 2
fila = [P1(burst=5), P2(burst=8), P3(burst=4), P4(burst=2)]
quantum = 2

enquanto fila não está vazia:
    processo = fila.remover_frente()
    executar(processo, min(quantum, processo.burst_restante))
    processo.burst_restante -= quantum
    se processo.burst_restante > 0:
        fila.inserir_atrás(processo)  # volta para o fim da fila
    senão:
        registrar_conclusão(processo)

Chamadas de sistema (syscalls)

Programas de usuário não acessam hardware diretamente — fazem requisições ao SO via syscalls:

# Programa de usuário faz chamada de sistema (syscall)
arquivo = abrir("dados.txt", "leitura")  # → syscall open()
dados = arquivo.ler(1024)               # → syscall read()
arquivo.fechar()                          # → syscall close()

# O SO verifica permissões e faz a operação real no hardware
# O programa não acessa o disco diretamente — passa sempre pelo SO

Implemente um escalonador

Mini projeto: implemente Round-Robin em Python com uma lista de processos [{"id": 1, "burst": 5}, ...] e um quantum configurável. Imprima a linha do tempo de execução.

Projeto principal: adicione suporte a prioridades: processos de maior prioridade entram na frente da fila. Compare o tempo médio de espera de Round-Robin vs. FCFS (First-Come, First-Served) vs. SJF (Shortest Job First).

Desafio extra: implemente preempção por prioridade: se um processo de alta prioridade entra na fila enquanto outro roda, o atual é interrompido imediatamente.

Teste sua intuição

Onde você encontra isso