Atenção: esse artigo tem um vídeo complementar. Clique e assista!

[lead]De que se trata o artigo:

Nesse artigo, veremos o que são threads, como são implementadas em Java e algumas de suas principais aplicações. Veremos também como se comunicar com threads que não estão executando e como esperar o encerramento de uma thread.

Para que serve:

Threads são a maneira mais popular de se escrever programas concorrentes, e são uma tecnologia central em Java. Seu uso pode tornar os programas mais rápidos e eficientes, além de melhorar a usabilidade.

Em que situação o tema útil:

Programas com trechos de algoritmos muito demorados podem aproveitar melhor vários núcleos de processadores, cada vez mais populares atualmente, se utilizarem threads. Por sua vez, programas que atendem várias requisições mas executam muitas operações de entrada/saída deixam de desperdiçar tempo de entrada/saída com espera, podendo executar ações paralelamente enquanto aguardam o resultado das E/S. Além disso, softwares interativos que executam algoritmos pesados podem usar threads para poderem atender a solicitações de seus usuários mesmo quando ocupados.[/lead]

Programas de computador são, geralmente, uma série de pequenos comandos executados em série: o processador executa um comando por vez, um atrás do outro, em uma ordem definida. Entretanto, nem sempre essa é a forma mais eficiente de se executar programas. Um programa pode desperdiçar muito tempo esperando o resultado de um comando que independe do processador; o computador pode ter mais de um núcleo processador; um algoritmo pode ser separado em partes que podem ser executadas paralelamente etc. Nesses casos, pode ser interessante paralelizar o programa, isto é, fazer partes do programa rodarem ao mesmo tempo – ou ao menos aparentemente ao mesmo tempo. Uma maneira muito prática e popular de se fazer isso é utilizando threads.

[subtitulo]Como threads funcionam[/subtitulo]

A Figura 1 representa um trecho de um programa em Java. Apesar de serem trechos de um só código, há conjuntos de comandos que dependem uns dos outros, mas que não influenciam o resultado de outras instruções. Por exemplo, este código pode ser dividido em três blocos independentes, que na figura são separados por linhas brancas. Embora estejam em uma ordem definida, não importa se o primeiro bloco é executado antes ou depois do segundo ou do terceiro: eles poderiam ter suas posições trocadas sem problemas. Na verdade, como os comandos não influenciam outros blocos, nada impede que se execute o primeiro comando do primeiro bloco seguido pelo primeiro comando do segundo bloco e assim por diante, alternando comandos de um e de outro bloco.

Figura 1. Representação de um programa linear.

Cada bloco do programa é independente: altera variáveis que não são usadas por nenhum outro trecho. Esse programa tem a forma ideal para ser paralelizado com threads. Para isso, os blocos devem ser convertidos em métodos e passados para uma classe específica, que os faria rodar em paralelo. Depois, o programa pode executar outras tarefas – mas, se em algum momento depender do resultado de uma das operações paralelas, deve esperar que a linha de execução da operação necessária termine. A Figura 2 apresenta uma representação gráfica deste programa.

Se o programa da Figura 2 for executado em um computador com mais de um processador, ou com um processador com mais de um núcleo, rodará mais rápido que sua versão linear da Figura 1, pois cada uma das partes pode ser executada em um núcleo, enquanto na versão linear apenas uma instrução pode ser executada por vez.

...
Quer ler esse conteúdo completo? Seja um assinante e descubra as vantagens.
  • 473 Cursos
  • 10K Artigos
  • 100 DevCasts
  • 30 Projetos
  • 80 Guias
Tenha acesso completo