Sistemas Distribudos e Paralelos ISUTIC Luanda, 2016

Guia para Laboratrio 1

Tema: Subprocessamento mltiplo.

Objectivo: Implementar programas simples para executar tarefas em subprocessos separados em Java.

Introduo

Um problema com os aplicativos de um sozinho subprocesso que as actividades que levam muito
tempo devem se completar dantes de que possam comear outras. Num aplicativo com
subprocessamento mltiplo, os subprocessos podem-se distribuir entre vrios processadores (se h
disponveis), de maneira que realizem se vrias tarefas em forma concorrente, o qual permite ao
aplicativo operar com mais eficincia.

Criao e execuo de subprocessos em Java:

O meio preferencial de criao de aplicativos Java com subprocessamento mltiplo implementando a

interface Runnable (do pacote java.lang). Um objeto Runnable representa uma "tarefa" que pode ser
executada simultaneamente com outras tarefas. A interface Runnable declara um nico mtodo, run,
que contm o cdigo que define a tarefa que deve realizar um objeto Runnable.

Exemplo 1

A classe TarefaImpresso implementa a interface Runnable, de modo que vrios objetos

TarefaImpresso podem ser executados simultaneamente.

Cada subprocesso que executa um objeto TarefaImpresso permanece inactivo durante o perodo de
tempo especificado por a varivel tempoInactividade, logo imprime o nome da tarefa e uma mensagem
indicando que terminou a sua inatividade. Um objeto TarefaImpresso executa-se quando um
subprocesso chama ao mtodo run de TarefaImpresso.

Mais tarde, no programa principal, objetos Thread so criados para executar objetos TarefaImpresso.
Logo faz-se uma chamada ao mtodo start de Thread na cada um dos subprocessos; a cada chamada
invoca ao mtodo run do objeto Runnable correspondente para executar a tarefa.

Actividade 1: Implemente o exemplo 1 num projecto em Java utilizando NetBeans. Depois execute
vrias vezes o aplicativo e valorize os resultados obtidos.

Observao: Voc deve se ter percatado de que o cdigo no mtodo main se executa no subprocesso
principal, que um subprocesso criado pela JVM. O cdigo no mtodo run de TarefaImpresso executa-
se nos subprocessos criados nas linhas 13 a 15 da figura 2. Quando termina o mtodo main, o programa
em sim continua se executando, j que ainda h subprocessos vivos. O programa no terminar sina at
que seu ltimo subprocesso termine de se executar, ponto no qual a JVM tambm terminar.

Administrao de subprocessos com o marco de trabalho Executor:

Ainda que possvel criar subprocessos em forma explcita, se recomenda utilizar a interface Executor
para administrar a execuo de objetos Runnable de maneira automtica. Pelo geral, um objeto
Executor cria e administra um grupo de subprocessos, ao qual se lhe denomina reserva de subprocessos,
para executar objetos Runnable. Os objetos Executor podem voltar a utilizar os subprocessos existentes
para eliminar a sobrecarga de criar um novo subprocesso para a cada tarefa.

A interface Executor declara um sozinho mtodo chamado execute, o qual aceita um objeto Runnable
como argumento. O objeto Executor atribui a cada objeto Runnable que passa a seu mtodo execute a
um dos subprocessos disponveis na reserva. Se no h subprocessos disponveis, o objeto Executor cria
um novo subprocesso, ou espera a que tenha um disponvel e o atribui ao objeto Runnable que passou
ao mtodo execute.
A interface ExecutorService (do pacote java.util.concurrent) uma interface que estende a Executor e
declara vrios mtodos mais para administrar o ciclo de vida de um objeto Executor.

Exemplo 2

A seguir utiliza-se um objeto ExecutorService para administrar subprocessos que executem objetos
TarefaImpresso. O mtodo main cria e nomeia trs objetos TarefaImpresso. Aqui utiliza-se o mtodo
newCachedThreadPool de Executors para obter um objeto ExecutorService que cria novos subprocessos,
segundo os vai precisando o aplicativo. Estes subprocessos utiliza-os ejecutorSubprocesos para executar
os objetos Runnable.

Ao invocar o mtodo execute de ExecutorService, este executa o objeto Runnable que recebe como
argumento (neste caso, um objeto TarefaImpresso), em algum momento no futuro. O mtodo execute
regressa imediatamente aps a cada invocao; o programa no espera a que termine a cada objeto
TarefaImpresso. Quando se faz uma chamada ao mtodo shutdown, este notifica ao objeto
ExecutorService para que deixe de aceitar novas tarefas, mas continua executando as tarefas que j se
tenham enviado.

Actividade 2: Implemente o exemplo 2 num projecto em Java utilizando NetBeans. Depois execute
vrias vezes o aplicativo e valorize os resultados obtidos.

Actividade 3: Implemente uma calculadora de nmeros de Fibonacci com interface grfica que
contenha um subprocesso concorrente em segundo plano que realize o clculo para depois o mostrar
em ecr. Isto evitar que o clculo recursivo extenso inhabilite a interface enquanto se realiza o mesmo.
A interface deve proporcionar componentes para que o utente escreva um nmero n e obtenha o n-
simo nmero de Fibonacci (mediante o uso do algoritmo recursivo). Como o algoritmo recursivo
consome muito tempo para valores extensos, deve se utilizar um objeto SwingWorker para realizar o
clculo num subprocesso trabalhador. A interface grfica tambm deve proporcionar um conjunto
separado de componentes que obtm o seguinte nmero de Fibonacci em sequncia com a cada clique
de um boto, comeando com fibonacci(1). Este conjunto de componentes realizar seu clculo curto
directamente no subprocesso de despacho de eventos. Desta maneira ser possvel obter o seguinte
nmero de Fibonacci enquanto o clculo recursivo ainda se est a realizar.

Tarefa:

Na actividade 3 deveu-se utilizar a classe SwingWorker para executar um processo extenso num
subprocesso em segundo plano, em onde a interface grfica se actualiza ao terminar o processo. Agora
deve se implementar um programa que actualize a interface grfica com resultados intermedirios
dantes de que o processo extenso termine. Implemente uma Calculadora de Nmeros Primos, a qual
deve estender a SwingWorker para calcular os primeiros n nmeros primos num subprocesso
trabalhador. A interface deve ir-se actualizando com os nmeros primos que tem ido calculando o
subprocesso trabalhador, ainda que este no tenha terminado. Para consegu-lo, devem utilizar-se os
mtodos publish, process e setProgress de SwingWorker.

Bibliografia:

DEITEL, P. J. e DEITEL, H. M. - JAVA Como Programar. 7ma Edio. 2007. Captulo 23.