Sistemas Operacionais

Threads

Professor Srgio Ricardo Rota

ndice

1. THREADS.....................................................................................................................2
1.1. BENEFCIOS DA PROGRAMAO COM MULTITHREADS.............................................................................2
1.2. THREADS EM MODO USURIO............................................................................................................... 4
1.3. THREADS EM MODO KERNEL................................................................................................................ 5
2. MODELOS DE GERAO DE THREADS..................................................................6
2.1. MODELO MUITOS-PARA-UM................................................................................................................... 6
2.2. MODELO UM-PARA-UM......................................................................................................................... 6
2.3. MODELO MUITOS-PARA-MUITOS............................................................................................................ 7
3. EXERCCIOS................................................................................................................9

4. REFERNCIAS............................................................................................................9
1. Threads

Um thread, tambm chamado de processo peso-leve (LWP lightweight

process), uma unidade bsica de utilizao da CPU: compreende um ID, um conjunto
de registradores e uma pilha. Um processo tradicional (processo peso-pesado) tem um
nico thread de controle. Se o processo possui mltiplos threads de controle
(multithreads), ele pode realizar mais do que uma tarefa a cada momento. A Figura 1
ilustra a diferena entre um processo tradicional com um nico thread e um processo com
mltiplos threads.

Figura 1 Processos com um nico thread e com multithreads.

Uma aplicao normalmente construda como um processo separado com

diversos threads de controle. Um navegador web pode ter um thread para exibir imagens
e texto enquanto outro thread recebe os dados da placa de rede. Um processador de
texto pode conter um thread para exibio de grficos, outro thread para leitura dos dados
digitados pelo usurio e um terceiro thread para verificao da grafia e da gramtica.

1.1. Benefcios da Programao com Multithreads

De forma simplificada, um thread pode ser definido como uma sub-rotina de um

programa que pode ser executada de forma assncrona, ou seja, executada
paralelamente ao programa que a chamou. Os threads compartilham o processador da
mesma maneira que os processos e, portanto, passam pelas mesmas mudanas de
estado execuo, bloqueado e pronto. Conforme mostra a Figura 2, dentro de um
mesmo processo, os threads compartilham o mesmo contexto de software e o mesmo
espao de endereamento, porm cada thread possui seu contexto de hardware
individual.

Captulo 2 Sistemas Operacionais Threads v1.7 Pgina 2 de 9

 Figura 2 Processo multithread.

Os benefcios da programao com multithreads podem ser classificados em trs

categorias principais:

1. Capacidade de resposta: A estruturao de uma aplicao interativa em

multithreads pode permitir ao programa continuar executando mesmo se parte
dele estiver bloqueada ou realizando uma operao prolongada, aumentando
deste modo a capacidade de resposta para o usurio. Por exemplo, um
navegador de web multithread poder permitir uma interao de usurio em um
thread enquanto uma imagem est sendo armazenada em outro thread.

2. Compartilhamento de recursos: Os threads compartilham a memria e os

recursos do processo ao qual pertencem. A vantagem do compartilhamento dos
recursos permitir que uma aplicao tenha diversos threads de atividade, tudo
dentro do mesmo espao de endereamento.

3. Economia de recursos: A alocao de memria e de recursos para a criao de

processos custosa. Por outro lado, como os threads compartilham recursos do
processo ao qual pertencem, mais econmico criar threads e comutar seus
contextos. Pode ser difcil medir empiricamente a diferena de sobrecarga para
criar e manter um processo em vez de um thread, mas, em geral, consome
muito mais tempo criar e gerenciar processos do que threads. No sistema
operacional Solaris (sistema operacional UNIX desenvolvido pela Sun
Microsystems), por exemplo, a criao de um processo cerca de 30 vezes
mais lenta do que a criao de um thread.

A utilizao de multithreads proporciona uma srie de benefcios. Em primeiro lugar,

programas concorrentes construdos com mltiplos threads so mais rpidos do que

Captulo 2 Sistemas Operacionais Threads v1.7 Pgina 3 de 9

programas concorrentes construdos com mltiplos processos, uma vez que as operaes
de criao, de troca de contexto e de eliminao dos threads geram uma menor
sobrecarga (overhead). Em segundo lugar, como os threads dividem o mesmo espao de
endereamento, a comunicao entre eles pode ser realizada de maneira rpida e
eficiente. Finalmente, threads de um mesmo processo podem compartilhar facilmente
outros recursos: arquivos abertos, timers, handles, etc.

1.2. Threads em Modo Usurio

Threads em modo usurio so construdos pela aplicao e no pelo sistema

operacional. Para tanto deve existir uma biblioteca de funes que possibilite aplicao
realizar tarefas como criar e eliminar threads, enviar e receber mensagens entre threads e
uma poltica de escalonamento. Neste modo, o sistema operacional no sabe da
existncia de mltiplos threads sendo a aplicao responsvel por gerenciar e sincronizar
os diversos threads existentes.

A vantagem deste modelo a possibilidade de construir aplicaes multithreads

mesmo em sistemas operacionais que no suportam threads (Figura 3). Exemplos:
sistema operacional OpenVMS verso 6 (Open Virtual Memory System)
(DEC/Compaq/HP), padro POSIX Pthreads e pacote MACH C-threads.
thread 1

thread 3

thread 5
thread 2

thread 4

biblioteca modo usurio

Figura 3 Threads em modomodo

kernel usurio.
kernel

A grande limitao deste modelo que o sistema operacional gerencia cada

processo como se existisse apenas um nico thread. No momento em que um thread
chama uma chamada de sistema que o coloca em estado de bloqueado, todo o processo
colocado no estado de bloqueado, mesmo havendo outros threads prontos para
execuo.

Alm disto, em relao ao escalonamento em sistema com mltiplos

processadores, no possvel que mltiplos threads de um processo possam ser
executados em diferentes processadores simultaneamente, pois o sistema operacional
seleciona apenas processos para execuo e no threads. Esta restrio limita
drasticamente o grau de paralelismo da aplicao, j que os threads de um processo
podem ser executados em somente um processador de cada vez.

Captulo 2 Sistemas Operacionais Threads v1.7 Pgina 4 de 9

1.3. Threads em Modo Kernel

Threads em modo kernel so construdos diretamente pelo ncleo do sistema

operacional, atravs de chamadas de sistema que oferecem todas as funes de
gerenciamento e sincronizao de threads (Figura 4).

O sistema operacional sabe da existncia de cada thread e pode escalon-lo

individualmente. No caso de mltiplos processadores, os threads de um mesmo processo
podem ser executados simultaneamente. Exemplos: sistemas operacionais Windows
2000/XP/Vista/7/8/10, Linux, OpenVMS verso 8 (Open Virtual Memory System)
(DEC/Compaq/HP) e Digital UNIX (DEC/Compaq/HP).
thread 1

thread 3

thread 5
thread 2

thread 4

modo usurio

Figura 4 Threads em modomodo

kernel kernel.
kernel

O grande problema no tratamento de threads em modo kernel o seu baixo

desempenho. Enquanto que no modo usurio todo o tratamento feito sem a ajuda do
sistema operacional, ou seja, sem a mudana do modo de acesso (usurio-kernel-
usurio), threads em modo kernel utilizam intensivamente chamadas de sistema e,
portanto, acarretam vrias mudanas no modo de acesso. A Tabela 1 compara o
desempenho de duas operaes distintas envolvendo a criao, escalonamento,
execuo e eliminao de processos e threads.

Tabela 1 Comparao entre tempos de latncia.

Construo Operao 1 [s] Operao 2 [s]

Subprocessos 11.300 1.840
Threads em Modo Kernel 948 441
Threads em Modo Usurio 34 37

Captulo 2 Sistemas Operacionais Threads v1.7 Pgina 5 de 9

2. Modelos de Gerao de Threads

Muitos sistemas oferecem suporte tanto para threads de usurio quanto do kernel,
resultando em diferentes modelos de gerao de threads.

2.1. Modelo Muitos-para-Um

O modelo muitos-para-um (Figura 5) mapeia muitos threads de nvel de usurio

para um thread do kernel. O gerenciamento dos threads realizado no espao do
usurio, sendo, portanto, eficiente, mas o processo inteiro ficar bloqueado se um thread
chamar uma chamada de sistema que o coloca em estado de bloqueado. Alm disto,
como somente um thread pode acessar o kernel a cada vez, mltiplos threads so
incapazes de executar em paralelo em sistemas com mltiplos processadores.

Figura 5 Modelo muitos-para-um.

As bibliotecas de threads de nvel de usurio utilizadas em sistemas operacionais

que no suportam threads de kernel utilizam o modelo muitos-para-um.

2.2. Modelo Um-para-Um

O modelo um-para-um (Figura 6) mapeia cada thread de nvel usurio para um

thread de nvel kernel. Este modelo prov mais concorrncia que o modelo muitos-para-
um, permitindo a outro thread executar quando um thread chamar uma chamada de
sistema que o coloca em estado de bloqueado. Este modelo tambm permite que

Captulo 2 Sistemas Operacionais Threads v1.7 Pgina 6 de 9

mltiplos threads sejam executados em paralelo em sistemas com mltiplos
processadores.

Figura 6 Modelo um-para-um.

A nica desvantagem deste modelo que a criao de um thread de nvel usurio

requer a criao do correspondente thread de nvel kernel. Como a sobrecarga para
criao de threads de nvel kernel pode comprometer o desempenho de uma aplicao, a
maior parte das aplicaes que utilizam este modelo restringe o nmero de threads
suportados pelo sistema. Por exemplo, os sistemas operacionais Windows
2000/XP/Vista/7/8/10 e OS/2 utilizam o modelo um-para-um.

2.3. Modelo Muitos-para-Muitos

O modelo muitos-para-muitos (Figura 7) mapeia muitos threads de nvel usurio

para um nmero menor ou igual de threads de nvel kernel. O nmero de threads de nvel
kernel pode ser especfico tanto para uma aplicao em particular quanto para uma
mquina em particular (uma aplicao pode alocar mais threads de nvel kernel em uma
mquina com mltiplos processadores do que em uma mquina com um nico
processador).

Captulo 2 Sistemas Operacionais Threads v1.7 Pgina 7 de 9

 Figura 7 Modelo muitos-para-muitos.

Ao mesmo tempo em que o modelo muitos-para-um permite ao desenvolvedor criar

tantos threads de usurio quantos julgar necessrios, a verdadeira concorrncia no
obtida porque o kernel pode agendar somente um thread de cada vez. O modelo um-
para-um permite maior concorrncia, mas o desenvolvedor tem que ser cuidadoso para
no criar threads em excesso dentro de uma aplicao.

J o modelo muitos-para-muitos no sofre destas falhas: Os desenvolvedores

podem criar tantos threads de usurio quantos forem necessrios e os correspondentes
threads de kernel podem executar em paralelo em um sistema com mltiplos
processadores. Alm disto, quando um thread chamar uma chamada de sistema que o
coloca em estado de bloqueado, o kernel pode agendar outro thread para execuo. Por
exemplo, os sistemas operacionais Solaris, IRIX (sistema operacional baseado no UNIX
BSD), o HP-UX (sistema operacional UNIX HP) e o Tru64 UNIX (sistema operacional
UNIX 64-bit para a arquitetura de microprocessador Alpha (HP)) suportam este modelo.

Captulo 2 Sistemas Operacionais Threads v1.7 Pgina 8 de 9

3. Exerccios

1) O que um thread? Quais as vantagens de sua utilizao?

2) Quais so as duas diferenas entre threads de nvel usurio e threads de nvel kernel?
Sob quais circunstncias um tipo melhor que outro?

3) Como o uso de threads pode melhorar o desempenho de aplicaes paralelas em

ambientes com mltiplos processadores?

4. Referncias

MACHADO, F. B.; MAIA, L. P. Arquitetura de Sistemas Operacionais. 3.ed. Rio de

Janeiro: Livros Tcnicos e Cientficos Editora, 2002.

OLIVEIRA, R. S.; CARISSIMI, A. S.; TOSCANI, S. S. Sistemas Operacionais. Porto

Alegre: Sagra-Luzzatto, 2001.

SILBERSCHATZ, A.; GALVIN, P.; GAGNE, G. Fundamentos de Sistemas

Operacionais. 6.ed. So Paulo: Livros Tcnicos e Cientficos Editora, 2004.

TANENBAUM, A. S. Sistemas Operacionais Modernos. 2.ed. So Paulo: Pearson

Prentice Hall, 2003.

Captulo 2 Sistemas Operacionais Threads v1.7 Pgina 9 de 9