Imagine que o seu computador tem apenas uma unidade de processamento central (CPU) que é capaz de executar apenas uma operação de cada vez. Agora, imagine o que aconteceria se a CPU trabalha-se duro para executar uma tarefa que leva um longo período de tempo para ser finalizada. Enquanto esta operação é executada, todas as outras operações serão pausadas fazendo com que sua máquina congele, isto é, o usuário não conseguirá utilizar nenhum recurso do sistema, fazendo com que o mesmo reinicie a máquina.
Para resolver esse problema, o conceito de Thread é utilizado. Nas versões atuais dos sistemas operacionais, cada aplicativo é executado em seu próprio processo. Um processo isola uma aplicação de outras aplicações dando-lhe a sua própria memória virtual e assegurando que processos diferentes não podem influenciar entre si. Cada processo é executado em seu próprio segmento. Um segmento é algo como um CPU virtualizado. Se um aplicativo trava ou bate um loop infinito, apenas o processo do aplicativo é afetado, não ocasionando o congelamento da máquina.
O sistema operacional deve gerenciar todas as Threads em execução para garantir que elas possam fazer o seu trabalho. Cada Thread é executada por um determinado período de tempo determinado pelo sistema operacional. Após o termino desse período, a Thread que esta sendo executada pelo sistema operacional entra em estado de pausa e o sistema operacional passa a executar outra Thread, isso é chamado de troca de contexto. Esse recurso dá a ilusão de que um processador pode executar várias tarefas ao mesmo tempo.
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
- Thread em modo kernel
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 operacionais que não suportam nativamente este recurso, sendo geralmente mais rápidas e eficientes pois dispensam o acesso ao núcleo. Evita assim mudança no modo de acesso, e a estrutura de dados fica no espaço do utilizador, levando a uma significativa queda de overhead, além de poder escolher entre as diversas formas de escalonamento em que melhor se adequa.
A gestão da thread (KLT) não é realizada através do código do próprio programa; todo o processo é subsidiado pelo SO. Esse modelo tem a vantagem de permitir o suporte a multiprocessamento e o facto do bloqueio de uma linha de execução não acarretar bloqueio de todo processo, não obstante, temos a desvantagem de ter que mudar o tipo de acesso sempre que o escalonamento for necessário, aumentando assim o tão temido overhead.
Há quatro operações básicas na gestão de threads: criar, terminar, thread join e thread yield.
- Criar (thread creation)
Basicamente uma thread pode criar outra(s), sendo que depois essas mesmas threads são executas ‘simultaneamente’. A thread criadora é a thread-mãe e a thread criada é a thread-filho. Threads incluídas na função main quando executadas podem criar threads-filho. No diagrama a seguir há a thread A que executa inicialmente. Mais tarde é criada a thread B indicada no ponto amarelo. Depois de criadas, a thread A e thread B executam simultaneamente. Em seguida a thread A pode criar uma ou mais threads (por exemplo uma thread C). Depois de criada a thread C, há três threads executando simultaneamente e todas disputam o uso da CPU. Entretanto, a thread que pode ser executada a qualquer momento não é de conhecimento da CPU.
- Terminar (thread termination)
Para maioria dos casos, as threads não são criadas e executadas eternamente. Depois de terminado o seu objectivo, a thread termina. No facto, a thread que criou estas duas threads-filho termina também, porque sua tarefa atribuída se completa. Na matrix de multiplicação (matrix multiplication), uma vez que o valor de C[i,j] é computado, a thread correspondente termina. Em geral quando a tarefa atribuída a thread completa, a thread pode ser terminada. Além disso, se a thread-mãe terminar, todas as threads filho terminam também. Porque isso é importante? Isso é importante porque as threads-filho compartilham recursos com a thread-mãe, incluindo variáveis. Quando a thread-mãe termina, todas as variáveis são perdidas e a thread-filho não poderá aceder aos recursos que a thread-mãe possuía. Assim, se a thread-mãe terminar mais cedo que a thread-filho haverá um problema! Uma thread pode terminar das seguintes maneiras:
- Retornando da sua rotina mais externa, a thread criadora.
- Quando termina a rotina em que foi começada.
- Chamando pthread_exit, fornecendo um estado de saída.
- Terminando através da função pthread_cancel
- Sincronizar(Thread Join)
Imagine a seguinte situação: Você está estudando para uma prova. Então você pede o seu irmão mais novo para comprar uma pizza. Neste caso você é a thread principal e seu irmão a thread-filho. Uma vez que você deu a ordem, você e seu irmão começam a “executar uma tarefa” simultaneamente. Agora há dois casos a se considerar: Primeiro: Seu irmão traz a pizza e termina enquanto você estuda. Nesse caso você pode parar de estudar e comer a pizza. Segundo: Você acaba de estudar mais cedo e dorme e depois a pizza chegará.
A junção de threads (thread join) é destinada para resolver este problema. A thread pode executar o thread join e aguardar até a outra thread terminar. No caso acima, você é a thread principal (thread main) e deve executar o thread joinaguardando o seu irmão (thread-filho) terminar. Em geral o thread join é utilizado para a thread-mãe se sincronizar com uma das threads-filho.
- Thread Yield (Rendimento da thread)
Suponha que você executa um certo número de programas o tempo todo no computador. Isso é possível devido a CPU escalonar pouco a pouco outros ciclos da CPU, assim outros programas podem ser executados. Isso pode ser um problema de política de planeamento do Sistema Operativo. Entretanto, quando escrevemos programas com múltiplas threads, temos que fazer correctamente para que algumas threads não ocupem a CPU eternamente, ou por um tempo muito longo sem abandoná-lo. Senão terminar na situação acima quando uma ou duas threads executam enquanto outras simplesmente esperam para retornar. Liberamos espaço na memória graças a thread yield. Quando a thread executa o thread yield, a execução da thread é suspensa e a CPU passa para uma outra thread em execução. Essa thread aguardará até a CPU tornar-se disponível novamente.
Fonte: wikipedia e exam ref 70-483
Acesse nosso canal no YouTube para visualizar outros vídeos sobre programação, como por exemplo Python, Java e Desenvolvimento de sistemas comerciais utilizando a linguagem C#.
Participe do nosso grupo de estudos no Facebook acessando o link https://www.facebook.com/groups/dfilitto/.
