Tarefas, Processos e Threads
Tarefas: Conceitos
Sistemas Monotarefa
Características (Anos 40):
- Uma tarefa por vez, carregada do disco para memória;
- Execução contínua até a conclusão, sem interrupção (Maziero, Cap. 3);
- Gerenciamento sequencial de dados de entrada/saída.
Tempo Compartilhado
Sistemas Multitarefa Preemptivos:
- CTSS (1961): Pioneiro no time-sharing (Corbató, 1963);
- Quantum: Intervalo de tempo por tarefa (ex.: 10-200ms no Linux – Tanenbaum, Cap. 2);
- Preempção: Suspende e retoma tarefas conforme necessidade (Silberschatz, Cap. 5).
Ciclo de Vida das Tarefas
Estados (Maziero, Cap. 3):
- Nova: Tarefa sendo criada;
- Pronta: Aguardando a alocação do processador;
- Executando: Em execução;
- Suspensa: Aguardando evento ou recurso;
- Terminada: Concluída.
Troca de Contexto
Definição: Salvar e restaurar o contexto de uma tarefa (TCB – Task Control Block) para permitir a alternância entre tarefas.
- TCB: Armazena registradores, contador de programa, etc. (Maziero, Cap. 3);
- Curiosidade: No Linux para Intel x86, as operações de troca de contexto estão definidas em Assembly no arquivo
arch/i386/kernel/process.cdos fontes do núcleo.
Processos
Processo: Uma tarefa associada a recursos (memória, arquivos, etc.) – Silberschatz, Cap. 3.
- Evolução: Historicamente, 1 tarefa = 1 processo; atualmente, um processo pode conter múltiplas tarefas.
- PCB: O Process Control Block armazena o estado e os recursos do processo (Maziero, Cap. 3).
Comandos Linux
Threads
Thread: Fluxo de execução dentro de um processo, com sua própria pilha e registradores, mas que compartilha os recursos do processo (Silberschatz, Cap. 4).
- User Threads (N:1): Mapeadas em uma única thread de kernel;
- Kernel Threads (1:1): Gerenciadas diretamente pelo SO (ex.: Linux, Windows);
- N:M: Modelo híbrido (ex.: Solaris, FreeBSD KSE);
- PThreads: Padrão POSIX para threads em C (Tanenbaum, Cap. 2).
Importante: Threads compartilham memória → podem causar problemas de concorrência (race conditions).
Animação: Criação de Threads
Processo (PID único)
Processo vs Threads
Processos
Memória A
Memória B
Memória C
Isolados
Threads
T1
T2
T3
Compartilham recursos
Threads no Linux (na prática)
No Linux, cada thread possui um identificador próprio (TID) e pode ser visualizada como um processo leve (LWP).
Exemplo Prático: Processo com Múltiplas Threads
Programa em Python que cria múltiplas threads dentro de um único processo:
import threading
import time
import os
def worker(id):
while True:
for _ in range(10000000): # pequena carga de CPU
pass
print(f"Worker {id} | PID: {os.getpid()} | TID: {threading.get_native_id()}")
time.sleep(1)
for i in range(3):
threading.Thread(target=worker, args=(i,), daemon=True).start()
while True:
time.sleep(10)
Observação: Um único processo (PID) cria várias threads (TIDs diferentes).
Como identificar o PID do programa
Forma 1 (recomendada): pgrep
pgrep -f threads.py
- Retorna diretamente o PID
- Mais limpo e preciso
Forma 2 (visual): htop
htop
- Pressionar F3
- Digitar python
- Observar a coluna PID
Forma 3 (background): $!
python3 threads.py & echo $!
- Retorna o PID do último processo em background
Forma 4 (alternativa): pidof
pidof python3
- Retorna todos os processos python
- Cuidado: não distingue facilmente o script
Fluxo da Demonstração
python3 threads.py pgrep -f threads.py ps -T -p PID top -H -p PID ls /proc/PID/task/
Interpretação:
- ps -T mostra quantas threads existem
- top -H mostra como cada thread usa CPU em tempo real
Prática: Monitoramento e Manipulação
Visualização e Controle de Processos
- Listar Processos:
ps -aux - Exibir Árvore de Processos:
pstree - Gerenciar Jobs:
sleep 60 &
jobs,fg,bg - Ajustar Prioridade:
nice -n 10 sleep 60
renicepara processos já em execução - Verificar PID e PPID:
echo $$
ps -o pid,ppid,comm -p $$
Identificar Processos Usando Portas com fuser
Inicie um servidor local:
sudo python3 -m http.server 80
Em outro terminal:
sudo fuser -n tcp -v 80
Finalizar processo da porta:
sudo fuser -k -n tcp 80
Script em Shell
#!/bin/bash
for i in {1..5}
do
echo "Processo em execução: $i"
sleep 1
done
Programa com Threads (Python)
import threading
import time
import os
def worker():
while True:
print("PID:", os.getpid(), "TID:", threading.get_native_id())
time.sleep(2)
for i in range(3):
threading.Thread(target=worker, daemon=True).start()
while True:
time.sleep(10)
Execute e depois use:
ps -T -p PID
top -H -p PID
Programa com Threads (C)
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
void *thread_func(void *arg) {
int id = *(int*)arg;
for (int i = 0; i < 5; i++) {
printf("Thread %d executando: %d\n", id, i);
sleep(1);
}
pthread_exit(NULL);
}
int main() {
pthread_t t1, t2;
int id1 = 1, id2 = 2;
pthread_create(&t1, NULL, thread_func, &id1);
pthread_create(&t2, NULL, thread_func, &id2);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
return 0;
}
Monitoramento de Processo (C)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void) {
pid_t pid = getpid();
printf("PID do processo: %d\n", pid);
fflush(stdout);
while(1) {
sleep(1);
}
return 0;
}
Compilação e Execução
gcc -o meu_programa meu_programa.c
./meu_programa
ps -ef | grep meu_programa
pgrep meu_programa
Ctrl + Z → bg → fg
nohup ./meu_programa &
Finalizar Processos com kill
- Finalizar via PID:
kill <PID> - Forçar finalização:
kill -9 <PID> - Por nome:
killall meu_programa - Via top: pressione
kdentro dotop - Usando htop (visual): selecione e pressione
F9 - Com pkill:
pkill -f meu_programa
Mini-Quiz
Bibliografia