DADist_Tema_04_Texto de apoio

Prévia do material em texto

CURSO DE CIÊNCIA DA COMPUTAÇÃO 
DISCIPLINA: DESENVOLVIMENTO DE APLICAÇÕES DISTRIBUÍDAS 
TEMA 04 – CONTINUAÇÃO DA PROGRAMAÇÃO CONCORRENTE 
 
TEXTO PARA APOIO AO ESTUDO 
 
1) Introdução 
Java suporta a programação multithreading, o que significa que os programas 
multithreading podem conter dois ou mais trechos de códigos que podem ser executados 
separadamente, lidando com tarefas diferentes ao mesmo tempo, otimizando o uso dos 
recursos disponíveis, especialmente em computadores que têm processadores com vários 
núcleos. 
O conceito de multitarefa é utilizado quando múltiplos processos compartilham 
recursos de processamento comuns como a CPU. Entretanto, o conceito de multithreading 
amplia o conceito de multitarefa, de modo que as aplicações possam subdividir operações 
específicas em threads individuais, que podem ser executadas em paralelo. Os Sistemas 
Operacionais não dividem o tempo de processamento apenas entre as aplicações diferentes 
mas, também, entre cada thread das aplicações. 
As aplicações desenvolvidas com Java são executadas por meio de threads, que são caminhos 
diferentes de execução do código do programa. Quando várias threads estão executando, o 
caminho de uma thread pode ser diferente do caminho de outra thread. 
 Vamos considerar, por exemplo, a estrutura switch/case, sendo que threads diferentes 
podem lidar com cada um dos cases. 
 Toda aplicação Java tem uma thread padrão que executa o método main(). A aplicação 
também pode criar threads que lidam com tarefas que demandem maior poderio 
computacional (como recursos de processamento e memória) executando em segundo plano, 
de modo que seja possível outros processamentos possam ser realizados como, por exemplo, 
responder aos acionamentos do mouse, do teclado, etc. Essas threads executam sequências de 
códigos encapsuladas em objetos que são denominados runnables. 
 A JVM fornece a cada thread sua própria pilha JVM para evitar que haja interferências 
entre threads diferentes. Esta abordagem de pilhas separadas permite que as threads 
acompanhem a próxima instrução a ser executada, que pode diferir de uma para outra thread. 
 É possível lidar com threads em Java de duas formas diferentes: 
• Classe java.lang.Thread; 
• Interface java.lang.Runnable. 
 
2) Ciclo de vida de uma thread 
 Uma trhead passa por diferentes estágios durante a sua existência. Usaremos os termos 
em Inglês objetivando facilitar o entendimento das funções que serão estudadas 
posteriormente. A Figura 1 ilustra o ciclo de vida das threads. 
 
Figura 1 – Ciclo de vida das threads. 
 
 Descrevendo textualmente, os estágios do ciclo de vida das threads são os seguintes: 
• New: uma nova thread é gerada e começa o seu ciclo de vida. Ela permanece neste 
estágio até que o programa inicie-a pelo método start(); 
• Runnable: depois que uma thread foi criada e inicializada, ela é considerada executável 
(Runnable); 
• Running: depois que uma thread entra no estado executável, é possível utilizar o 
método run() para, de fato, executá-la, de modo que ela realize o processamento que 
foi designada a fazer; 
• Waiting: objetivando a sincronização dos processamentos das threads, 
frequentemente, é necessário utilizar recursos que possam atrasar a continuidade do 
processamento das threads, de modo que elas possam esperar que outras threads 
realizem seus processamentos antes que ela continue o seu. Por meio dos métodos 
sleep() e wait(), podemos estabelecer a sincronização. 
• Dead: quando a thread é finalizada. 
 
3) Prioridades das threads 
 Cada thread em Java tem uma prioridade que ajuda o Sistema Operacional a determinar 
a ordem na qual as threads serão executadas. 
 As prioridades de threads em Java variam de MIN_PRIORITY (valor 1) até MAX_PRIORITY 
(valor 10). Por padrão, cada thread é atribuída à prioridade NORM_PRIORITY (valor 5). 
 Threads com altas prioridades são mais importantes para um programa e devem ser 
alocados tempos de processamento para que elas sejam executadas antes das threads com 
menores níveis de prioridades. Entretanto, é importante atentar para qualquer alteração que se 
considere fazer nos níveis de prioridade porque eventuais erros podem comprometer o 
processamento. 
 
4) Utilização de threads por meio da interface Runnable 
 Se uma determinada classe precisa ser executada como uma thread, então podemos 
implementar por meio da interface Runnable. 
 Inicialmente, precisamos executar o método run() fornecido pela interface Runnable. 
Este método run() fornece um ponto de entrada para a thread e digitaremos, dentro deste 
método, as linhas de código que desejamos executar. A sintaxe deste método está mostrado a 
seguir: 
 
 
 Em seguida, instanciaremos um objeto do tipo Thread, usando o construtor mostrado a 
seguir: 
 
 
 Sendo que threadObj é a instância de uma classe que implementa a interface Runnable. 
E threadName é o nome dado para a nova thread. 
 Uma vez que o objeto Thread é criado, pode-se inicializa-lo por meio da invocação do 
método start() que, por sua vez, executa a chamada para o método run(). 
 
 Vamos ver agora um exemplo completo, que utiliza as funções descritas acima. 
 
 
 A saída do programa será: 
 
 
 
 
 
5) Utilização de threads por meio da classe Thread 
 Outra possibilidade de criação de threads é por meio da classe Thread. A princípio, é 
preciso sobrescrever o método run(), que está disponível na classe Thread. De modo semelhante 
ao caso anterior, este método também fornece um ponto de entrada para thread e 
escreveremos nosso código dentro deste método. 
 
 Ainda de forma semelhante ao caso anterior, uma vez que um objeto Thread é 
instanciado, ele é iniciado por meio do método start(), que chama o método run(). 
 
 Vamos ver também um exemplo completo: 
 
 E a saída do programa será: 
 
 
 
 
 
 
 
 
 
 
 A classe Thread tem funcionalidades que possibilitam a utilização dos recursos 
necessários do Sistema Operacional que, normalmente, possibilitam a criação e gerenciamento 
de threads. 
 A interface Runnable tem o código necessário para ser executados pela thread que está 
associada com um objeto Thread. Este código está localizado no método run() de Runnable. 
 Com exceção da thread associada ao método main(), as threads são introduzidas por 
meio dos objetos Thread e Runnable. Thread declara vários construtores para a inicialização de 
objetos Thread. E vários destes construtores requerem um objeto Runnable como argumento. 
 Há duas maneiras de se criar um objeto Runnable. A primeira delas considera a criação 
de uma classe anônima que implementa Runnable, conforme mostrado a seguir: 
 
 No código acima, é criado o objeto r, que é do tipo Runnable. 
Ants do Java 8, esta era a única maneira de criar um runnable. Porém, Java 8 introduziu 
a denominada expressão lambda, que permite que se crie runnable de forma mais simplificada, 
conforme mostrado a seguir: 
 
 
 Depois da criação do objeto Runnable (r), pode-se passa-lo como parâmetro de entrada 
do construtor Thread que recebe um argumento do tipo Runnale, conforme mostrado no 
fragmento de código abaixo: 
 
 O código acima criou então um objeto t, que é do tipo Thread, a partir de um objeto r, 
do tipo Runnable. 
 Mas alguns construtores podem não utilizar argumentos do tipo Runnable e, nestes 
casos, é necessário sobrescrever seu método run() para possibilitar a execução do código, 
conforme mostra o fragmento de código abaixo: