5-Aula-Threads

(1)

Sistemas Operacionais

Threads

(2)

(3)

Uma thread é uma unidade básica,

fundamental de utilização de CPU.

(4)

• Até agora estudamos processos como um

programa em execução com uma única thread de controle. Mas a maioria dos sistemas

operacionais modernos permitem que os processos tenham mais de uma thread de controle para uma mesmo processo.

(5)

(6)

• Uma thread é composta por:

– Um contador de programa

– Um conjunto de registradores – Uma pilha

• Além disso ela compartilha com outras

threads sua seção de código, seção de dados e alguns outros recursos como arquivos

abertos.

(7)

• Um sistema tradicional que é dotado de uma única thread é chamado de single-threaded, e um sistema em que os processos são dotados de múltiplas threads é chamado de

multi-threaded.

(8)

(9)

(10)

• Processos grandes (pesados) se fossem

criados baseados em uma única thread seriam demasiado lentos. Devido a este fato

abordagens com múltiplas threads são muito desejáveis.

(11)

• Exemplos:

– Um navegador web pode ter uma thread exibindo imagens, outra exibindo texto e uma terceira

recebe dados da rede.

– Um processador de texto pode ter uma thread para exibir gráficos, outra para “ler” os toques do teclado e outra ainda para realizar a verificação ortográfica.

(12)

• Mas estes ainda são exemplos que poderiam funcionar sem threads, com uma sensível queda no desempenho e no modo como utilizamos o computador.

• Agora imagine um exemplo de um servidor web que aceita requisições de clientes e fornece páginas, textos, imagens, sons, etc. Imagine ter de esperar pelo primeiro cliente fechar a página para que você possa acessá-la.

(13)

• Uma possível solução para esse processo é fazer com que cada cliente seja atendido por um novo processo, mas a criação de um processo exige muito mais recursos que a criação de uma thread.

• Se o novo processo tiver de realizar as mesmas tarefas para que assumir todo este custo ao invés de criar apenas uma nova

(14)

(15)

• Então podemos resumir os benefícios da utilização de threads em quatro principais categorias:

– Responsividade

– Compartilhamento de recursos – Economia

– Utilização de arquiteturas multiprocessadas

(16)

• Responsividade: o uso de threads faz com que uma aplicação fique mais interativa pois permite que o programa continue funcionando mesmo que uma parte dele esteja bloqueada devido a uma operação longa. Exemplo: um navegador web carregando um vídeo em uma página permite que você continue interagindo com a página.

(17)

• Compartilhamento de recursos: como as threads compartilham memória e recursos do processo ao qual pertencem um grande benefício é que é possível criar várias threads dentro do mesmo espaço de endereçamento.

(18)

• Economia: alocar memória e recursos para criação de processos é caro para o sistema. Devido ao fato de as threads compartilharem tais recursos do processo aos quais pertencem é mais econômico criar e realizar trocas de contexto de threads.

(19)

• Economia: é difícil quantificar esta diferença de performance mas é fato de que a criação de processos é mais demorada. Por exemplo no sistema Solaris, foi constatado por testes empíricos que a criar um processo demora 30 vezes mais do que criar um thread.

(20)

• Utilização de arquiteturas multiprocessadas: os benefícios podem ser maximizados em arquiteturas multiprocessadas, como já é comum um computador com um processador dotado de vários núcleos dividir um processo em várias threads permite que cada uma delas execute paralelamente em um core diferente, fato que não seria conseguido caso o processo tivesse uma única thread de controle.

(21)

MODELOS DE MÚLTIPLAS THREADS

(MULTITHREADING)

(22)

• Estudando a fundo o modo como as threads são executadas é importante observar que o suporte a threads é fornecido em dois níveis:

– Threads de usuário: são admitidas acima do kernel, sendo assim seu gerenciamento não depende do kernel do sistema.

– Threads de kernel: são admitidas e gerenciadas diretamente pelo sistema operacional.

(23)

• Quase todos os sistemas operacionais modernos admitem threads de kernel como por exemplo:

– Windows XP

– Linux (todas as distros) – Mac OS X

– Solaris

(24)

• Para que tudo funcione é necessário que haja um relacionamento entre as threads de usuário e de kernel, visto que somente em modo núcleo o hardware pode ser acessado por completo.

• Este relacionamento pode ser feito de três formas fundamentais:

– Modelo muitos para um – Modelo um para um

– Modelo muitos para muitos

(25)

• Modelo muitos para um

• Este modelo associa muitas threads de usuário a apenas uma thread de kernel.

• O gerenciamento é feito pela biblioteca de threads de usuário.

• Um problema é que se uma thread solicita alguma operação em que a thread de sistema efetua uma operação bloqueante o processo

(26)

• Outro ponto negativo é que neste modelo não é possível que várias threads sejam executadas em vários processadores em paralelo.

(27)

(28)

• Modelo um para um

• Neste modelo cada thread de usuário é associada a uma thread de kernel.

• Ele provê maior concorrência pois supera os dois problemas propostos na solução anterior (muitos para um) pois caso uma thread acesse uma operação bloqueante outras threads ainda podem executar, além do fato de permitir a execução de várias threads em paralelo em multiprocessadores.

(29)

• Uma desvantagem deste modelo é que cada thread de usuário requer a criação de uma thread de kernel, como isso tem um custo de recursos físicos é comum que os sistemas tenham restrições quanto a quantidades de threads criadas, para garantir o bom

(30)

• O Linux, juntamente com as famílias Windows (98, NT, 2000 e XP) implementam este modelo.

(31)

(32)

• Modelo muitos para muitos

• Este modelo multiplexa muitas threads de usuário para muitas threads de kernel, ou seja, várias threads de usuário são associadas a um número igual ou menor de threads de kernel.

• Estes números podem variar dependendo da aplicação e também da arquitetura do sistema.

(33)

• Este modelo não sofre nenhuma das limitações citadas anteriormente, pois os desenvolvedores podem criar quantas threads de usuário que necessitarem, as threads de kernel serão executadas paralelamente e caso uma delas chame uma operação bloqueante

(34)

(35)

• Há ainda uma variação desse modelo que é um tipo de híbrido entre os modelos um para um e muitos para muitos, ela é chamada de modelo de dois níveis (two level model).

(36)

• Modelo de dois níveis

(37)

(38)

• Uma biblioteca threads fornece ao programador uma API para criação e o gerenciamento de threads.

• Existem duas formas de implementação de bibliotecas de threads: A primeira é fornecer uma biblioteca inteiramente no espaço de usuário, sem suporte a kernel. Todo o código e estrutura estão no espaço de usuário.

(39)

• A segunda é implementar um biblioteca a nível de kernel, com suporte direto ao sistema operacional, nesta abordagem o código e as estruturas ficam no espaço de kernel e as chamadas de funções na API resultam em uma chamada de sistema.

• Atualmente três bibliotecas estão em uso:

– POSIX Pthreads – Win32

(40)

• POSIX Pthreads

– Comumente utilizada em sistemas Solaris, Linux, Mac OS e UNIX

– Pode ser fornecida como uma biblioteca em nível de usuário ou de kernel.

• Win32

– É a biblioteca disponível nos sistemas Windows – É uma biblioteca em nível de kernel

(41)

• Java

– Essa API permite a criação e gerência de threads diretamente em um programa Java.

– Roda dentro de uma JVM (Java Virtual Machine) por isso normalmente é implementada usando a biblioteca disponível nos sistemas hospedeiro.