Sistemas Operacionais I

Gerências de Processos: Threads

Prof. Alexandre Duarte : http://alexandrend.com

Centro de Informática | Universidade Federal da Paraíba

Estes slides são baseados no material que acompanha o livro Operating

Systems Concepts de Silberschatz, Galvin and Gagne
Objetivos
¨ Introduzir a noção de thread, uma unidade
fundamental de utilização de CPU e que
representa a base da maioria dos sistemas
computacionais modernos

¨ Questões relacionadas a criação de threads

 O que há em um processo

¨ Um processo consiste em (pelo menos):

¤ Um espaço de endereçamento, contendo
n O código (instruções) do programa em execução
n Os dados do programa

¤ Um fluxo de execução, consistindo de:

n O contador de programa indicando a próxima instrução
n O registrador do ponteiro da pilha (então também a pilha)
n Outros registradores

¤ Um conjunto de recursos do SO
n Arquivos abertos, conexões de rede, canais de áudio…
 O que precisamos?

¨ Em muitos casos
¤ Todos precisam executar o mesmo código
¤ Todos precisam acessar os mesmos dados
¤ Todos precisam ter os mesmos privilégios
¤ Todos usam os mesmos recursos (arq. abertos, conexões de rede, etc)

¨ Porém gostaria de ter múltiplos estados de execução:

¤ Uma pilha de execução e um ponteiro para a pilha
n trace das chamadas de procedimentos realizadas
¤ O contador de programa, indicando a próxima instrução
¤ Um conjunto de registradores de propósito geral e seus valores
 O que precisamos?
¨ Em muitos casos
¤ Todos precisam executar o mesmo código
¤ Todos precisam acessar os mesmos dados
Todos precisam ter os mesmos privilégios
Processo
¤

¤ Todos usam os mesmos recursos (arq.

abertos, conexões de rede, etc)
Código
¨ Porém gostaria de ter múltiplos estados de
execução: Dados
¤ Uma pilha de execução e um ponteiro para a
pilha
n trace das chamadas de procedimentos
Arquivos
realizadas
¤ O contador de programa, indicando a
próxima instrução
Pilha
¤ Um conjunto de registradores de propósito
geral e seus valores
Registradores
 Como alcançar isto

¨ De acordo com o que vimos em processos

¤ Criar vários processos (fork)
¤ Fazer cada um mapear para a mesma área física de memória
para compartilhar dados

¨ Ineficiente
¤ Espaço: PCB, tabela de páginas, etc
¤ Tempo: Criar estruturas do SO, criar/copiar espaços de
endereçamento, etc
 É possível fazer melhor?

¨ Ideia chave:
¤ Separar o conceito de processo (espaço de endereçamento,
recursos de SO)
¤ … do fluxo de controle mínimo (pilha, ponteiro para pilha,
contador de programa, registradores)

¨ Este fluxo de controle é geralmente chamado de thread ou

processo leve.
 Threads e processos

¨ Maioria dos SOs modernos suportam duas entidades:

¤ O processo, que define o espaço de endereçamento e atributos gerais
¤ A thread, que define fluxo sequencial de execução dentro de um
processo

¨ Uma thread é restrita a um processo / espaço de endereçamento

¤ Contudo, espaços de endereçamento podem ter múltiplas threads
executando
¤ Compartilhamento de dados entre threads é barato: todas “veêm” o
mesmo espaço de endereçamento
¤ Criar threads também é barato

¨ Threads tornaram-se a unidade básica de escalonamento

¤ Processo são apenas containers nas quais as threads executam
Processo com thread único e com
múltiplos threads
Comunicação
¨ Threads são execuções concorrentes
compartilhando um espaço de endereçamento (e
alguns recursos do SO)
¨ Espaços de endereçamento fornecem isolamento
¤ Se não está no espaço, não pode ler nem escrever
¨ Portanto, comunicação entre processos é custosa
¤ Deve passar pelo SO para mover dados de um espaço
para outro
¨ Porque threads estão no mesmo espaço de
endereçamento, a comunicação é barata/simples
¤ Apenas atualiza uma variável compartilhada
 Espaço deThe
endereçamento
design space

Key
older
MS/DOS UNIXes

address one thread per process one thread per process

space one process many processes

thread
Java Mach, NT,
Chorus,
Linux, …
many threads per process many threads per process
one process many processes
Espaço de endereçamento de um
(old)(antigo)
processo Process address space

0xFFFFFFFF
stack
(dynamic allocated mem)
SP

address space heap

(dynamic allocated mem)

static data
(data segment)

code PC
(text segment)
0x00000000
Espaço de endereçamento de um
processo (novo)
(new) Address space with threads
thread 1 stack
SP (T1)
0xFFFFFFFF
thread 2 stack
SP (T2)

thread 3 stack
SP (T3)
address space

heap
(dynamic allocated mem)

static data
(data segment)
0x00000000 PC (T2)
code
PC (T1)
(text segment)
PC (T3)
Exemplos
¨ Navegador web
¤ Thread para exibir imagens
¤ Thread para recuperar dados da rede

¨ Processador de texto
¤ Thread exibir gráficos
¤ Thread para ler sequência de teclas

¤ Thread para realizar a verificação ortográfica

¨ Servidor web com várias threads com a

mesma função
Benefícios
¨ Responsividade
¤ Mesmo com uma parte do programa bloqueado,
continua a funcionar (web browser)
¨ Compartilhamento de recursos
¤ Recursos do processo no mesmo espaço de
endereçamento
¨ Economia
¤ Criar e comutar: threads X processos
Arquitetura de um servidor multi-threaded
Tipos de threads: núcleo (kernel)
¨ gerenciamento das threads é feito pelo núcleo
¨ Criação, escalonamento, chaveamento e finalização

¨ núcleo mantém a informação de contexto para

processo e threads

¨ bloqueio de uma thread não bloqueia as outras

¨ Se uma thread bloqueia (e.g., E/S), o SO sabe e pode
executar outras threads daquele processo
Tipos de threads: núcleo (kernel)
¤ threads podem aproveitar a capacidade de
multiprocessamento

¨ Porém:
¤ a transferência de controle entre threads de um mesmo
processo requer chaveamento para modo núcleo
(chamadas de sistemas)

¤ chaveamento de threads = troca de contexto (no entanto

mais barata que troca de contexto de processos)
 Tipos de threads: núcleo (kernel)
Kernel threads

Mach, NT,
Chorus,
address
Linux, …
space

os kernel
thread CPU
(thread create, destroy,
signal, wait, etc.)
Tipos de threads: usuário
¨ gerenciamento das threads é feito pela aplicação
¤ sem intervenção do SO
¨ o núcleo desconhece a existência de thread
¨ bibliotecas para
¤ criação e destruição de threads
¤ envio de msgs
¤ escalonamento de threads
¤ salvamento e recuperação de contexto
¨ chaveamento entre threads não requer privilégio de
modo núcleo
Tipos de threads: usuário
¤ implementadas através de bibliotecas: executam em
qualquer SO

¨ Porém:
¤ chamada ao sistema bloqueia todas as threads de um
processo (para o SO é só um processo)
¤ não aproveita os benefícios do multiprocessamento
(estão em algum processo!)
Tipos de threads: usuário
User-level threads
user-level
thread library

(thread create, destroy,

signal, wait, etc.)

os kernel
CPU
 Tipos de threads: usuário
User-level threads: what the kernel see
¨ O que o kernel vê

address
space

os kernel
thread CPU
 Tipos de threads: usuário
¨ Problema: se um thread de usuário bloqueia, por exemplo
por E/S, todas as outras do mesmo processo bloqueiam
User-level threads
user-level
thread library

(thread create, destroy,

signal, wait, etc.)
Mach, NT,
Chorus,
dress
Linux, …
pace

kernel threads
os kernel
read CPU
(kernel thread create, destroy,
signal, wait, etc.)
Exemplo de desempenho (antigo)

¨ Em um Pentium 700MHz rodando Linux 2.2.16.

¨ Apenas diferença relativa entre os valores importa.
IGNOREM a CPU antiga.

¨ Processo
¤ criar: 251 μS

¨ Thread de kernel
¤ criar: 94 μS (2,5 vezes mais rápido)

¨ Thread de usuário
¤ criar: 4,5 μS (20 vezes mais rápido)
Modelos de Multi-threading
¨ Muitos-para-um

¨ Um-para-um

¨ Muitos-para-muitos
Muitos-para-um
¨ Muitas threads do
usuário mapeadas para
uma única thread do
núcleo
¨ Não tira vantagem de
sistemas
multiprocessadores
¨ Exemplos:
¤ Solaris Green
Threads
¤ GNU Portable
Threads
Um-para-um
¨ Cada thread do usuário é mapeada uma uma thread
do núcleo (também é uma desvantagem -> restringe
nº de threads)
¨ Exemplos
¤ Windows NT/XP/2000
¤ Linux
¤ Solaris 9 e posterior
Muitos-para-muitos
¨ Permite que muitas
threads do usuário
sejam mapeadas em
muitas threads do
núcleo (menor ou
igual)
¨ Exemplos
¤ Solaris antes da
versão 9
¤ Windows NT/2000
como o pacote
ThreadFiber
Modelo em dois níveis
¨ Similar ao M:M porém
também permite que
uma thread do
usuário seja
associada a uma
thread do núcleo
¨ Exemplos
¤ IRIX
¤ HP-UX
¤ Tru64 UNIX
¤ Solaris 8 e anteriores
Bibliotecas de threads
¨ Bibliotecas de threads oferecem uma API para
criação e manipulação de threads

¨ Win 2000 Threads

¤ Implementação do modelo um para um no kernel;
Pthreads
¨ Pode ser fornecida tanto no nível do usuário
quanto no núcleo
¨ API padrão POSIX (IEEE 1003.1c) para
criação e sincronização de threads
¨ A API especifica unicamente o comportamento
da biblioteca, a implementação fica a cargo
dos desenvolvedores
¨ Comum em sistemas operacionais UNIX
(Solaris, Linux, Mac OS X)
Java Threads
¨ Threads em Java são gerenciados pela JVM

¨ Tipicamente implementados de acordo com o

modelo de threads do sistema operacional
“hospedeiro”

¨ Threads em Java podem ser criados

¤ Estendendo a classe Thread
¤ Implementando a interface Runnable
Questões relacionadas a criação de
threads
¨ As chamadas de sistema fork() e exec()

¨ Cancelamento de threads
¤ Assíncrono versus adiado

¨ Pools de Thread
As chamadas de sistema fork() e exec()

¨ O fork() duplica apenas a thread que invocou

a chamada ou todos as threads do programa ?
¨ O que acontece com o exec() ?
 As chamadas de sistema fork() e exec()

P1: T1 e T2
T2:fork()
P2

P1: T1 e T2 P1: T1 e T2
T2:fork() T2:fork()
P2: T1 e T2 P2:T2
exec()
P2
Cancelamento de threads
¨ Cancelar uma thread antes de sua conclusão

¨ Problema no compartilhamento de recursos

¨ Duas abordagens
¤ Cancelamento assíncrono: termina a thread alvo
imediatamente. Pode não liberar recursos
necessários a nível de sistema
¤ Cancelamento adiado: permite que a thread alvo
verifique periodicamente se ela deve ser cancelada
Pool de threads
¨ Cria um número de threads em um pool onde
elas aguardam por trabalho

¨ Vantagens:
¤ Geralmente é um pouco mais rápido requisitar
uma thread já existente do que criar uma nova
thread
¤ Permite que o número de threads na(s)
aplicação(ões) seja limitado ao tamanho do pool
Exercício

¨ É possível ter execução concorrente de threads/processos sem

paralelismo? Como?

¨ Considere um processo que usa biblioteca de threads de usuário e cria 10

threads de usuário. A SO mapeia estas 10 threads em 2 threads de kernel.
O processo executa em um sistema com 8 núcleos. Qual o número
máximo de threads de usuário que podem executar em paralelo?
Exercício

Quantos processos e quantas threads existirão neste trecho de código.

Incluindo o processo/thread que inicia a operação (processo pai). Assuma que
o comando thread_create( . . . ) criar uma thread e esta thread termina logo
em seguida, ou seja, ela não executa mais nenhuma instrução.

pid_t pid;
1 pid = fork();
2 if (pid == 0) { // Child process
3 fork();
4 thread_create( . . . );
}
5 fork();
Exercício

P1/T1
Linha 1 Linha 5

P2/T2 P3/T3
Linha 5
Linha 3
Linha 4

P4/T4 T2.1 P6/T6

Linha 4 Linha 5

T4.1 P5/T5

Resposta: 6 processos e 8 threads