Threads

Thread (ciência da computação)

Origem: Wikipédia, a enciclopédia livre.

NoFonti.svg

Este artigo ou se(c)ção cita uma ou mais fontes fiáveis e independentes, mas ela(s) não cobre(m) todo o texto (desde dezembro de 2013).

Por favor, melhore este artigo providenciando mais fontes fiáveis e independentes e inserindo-as em notas de rodapé ou no corpo do texto, conforme o livro de estilo.

Encontre fontes: Google — notícias, livros, acadêmico — Scirus — Bing. Veja como referenciar e citar as fontes.

Disambig grey.svg Nota: Para outros significados de thread, veja thread (desambiguação).

Linha ou Encadeamento de execução (em inglês: Thread), é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas concorrentemente. O suporte à thread é fornecido pelo próprio sistema operacional, no caso da linha de execução ao nível do núcleo (em inglês: Kernel-Level Thread (KLT)), ou implementada através de uma biblioteca de uma determinada linguagem, no caso de uma User-Level Thread (ULT).

Uma thread permite, por exemplo, que o usuário de um programa utilize uma funcionalidade do ambiente enquanto outras linhas de execução realizam outros cálculos e operações.

Em hardwares equipados com uma única CPU, cada thread é processada de forma aparentemente simultânea, pois a mudança entre uma thread e outra é feita de forma tão rápida que para o utilizador isso está acontecendo paralelamente. Em hardwares com múltiplos CPUs ou multi-cores, as threads são realizadas realmente de forma simultânea;

Os sistemas que suportam apenas uma única thread (em real execução) são chamados de monothread enquanto que os sistemas que suportam múltiplas threads são chamados de multithread.

Índice [esconder]

1 Exemplo

2 Particularidades

3 Estados de uma linha de execução

4 ULT e KLT

5 Escalonamento

6 Comparação entre linha de execução e Processo

7 Modelo de Geração de Multithreads

8 Cancelamento

9 Exemplos

9.1 Java

9.2 Java, exemplo simples em português

9.3 C

9.4 C++

9.5 Ruby

9.6 Delphi

10 Referências

Exemplo[editar | editar código-fonte]

Um exemplo simples seria um jogo, que pode ser modelado com linhas de execução diferentes, sendo uma para desenho de imagem e outra para áudio. Neste caso, há um thread para tratar rotinas de desenho e outro thread para tratar áudio; No ponto de vista do usuário, a imagem é desenhada ao mesmo tempo em que o áudio é emitido pelos alto-falantes; Porém, para sistemas com uma única CPU, cada linha de execução é processada por vez.

Particularidades[editar | editar código-fonte]

Cada thread tem o mesmo contexto de software e compartilha o mesmo espaço de memória (endereçado a um mesmo processo-pai), porém o contexto de hardware é diferente. Sendo assim o overhead causado pelo escalonamento de uma thread é muito menor do que o escalonamento de processos. Entretanto não há acesso protegido à memória nativa (sua implementação fica a cargo do programador) devido ao compartilhamento do espaço de memória.

Um dos benefícios do uso das threads advém do facto do processo poder ser dividido em várias threads; quando uma thread está à espera de determinado dispositivo de entrada/saída ou qualquer outro recurso do sistema, o processo como um todo não fica parado, pois quando uma thread entra no estado de 'bloqueio', uma outra thread aguarda na fila de prontos para executar.

Uma thread possui um conjunto de comportamentos padrão, normalmente encontrados em qualquer implementação ou sistema operativo.

Uma thread pode:

criar outra da mesma forma que um processo, através do método thread-create, onde a thread retorna um ID como primeiro argumento (resultado da função de criação);

esperar outra thread se sincronizar, através do método join;

voluntariamente "desistir" da CPU por não precisar mais do processamento proposto pela própria ou por vontade do utilizador. Feito através do método thread-yield;

replicar-se sem a necessidade de duplicar todo o processo, economizando assim memória, processamento da CPU e aproveitando o contexto (variáveis, descritores, dispositivos de I/O).

Estados de uma linha de execução[editar | editar código-fonte]

Uma thread pode assumir os seguintes estados:

Unstarted: logo após ser criada (antes do Start());

Running: após ser ativada (Start()) ou após método Resume();

Suspended: após método Suspended();

Stopped: após método Abort().

ULT e KLT[editar | editar código-fonte]

Usualmente as threads são divididas em duas categorias: thread ao nível do utilizador (em inglês: User-Level Thread (ULT)), e thread ao nível do núcleo (em inglês: Kernel-Level Thread (KLT)).

Thread em modo usuário

Ult.jpg

Thread em modo kernel

Klt.jpg

As threads da primeira categoria (ULT) são suportadas pela aplicação, sem conhecimento do núcleo e geralmente são implementadas por pacotes de rotinas (códigos para criar, terminar, escalonamento e armazenar contexto) fornecidas por uma determinada biblioteca de uma linguagem, como é o caso da thread.h (biblioteca padrão da linguagem C). Estas threads suportam as mesmas operações que as threads KLT (criar, sincronizar, duplicar e abortar). Possuem como vantagens a possibilidade de implementação em sistemas operativos que não suportam nativamente este recurso, sendo geralmente mais rápidas e eficientes pois