O que e uma thread? - Dei-Isep

LINGUAGENS E PROGRAMAÇÃO II
TRABALHO ESCRITO
THREADS
JOSE ANTONIO AROSO DOS SANTOS
Nº1000273
O que e uma thread?
Uma thread é basicamente uma sequência de instruções que vão ser executadas num
programa. Podem existir várias threads dentro de um processo (programa em execução
com o seu próprio espaço de endereçamento), mas cada uma delas é executada
independentemente, isto é, dentro de um processo podem existir várias threads em
execução. As threads podem ser vistas como entidades independentes pelo Sistema
Operativo, sendo por isso escalonáveis, sendo executadas independentemente dentro do
processo.
Threads, para que servem?
O uso de threads tem utilidade quando queremos, por exemplo, fazer uma verificação
contínua em fundo, sem que isso afecte significativamente o programa que está a ser
utilizado, por exemplo, um servidor web pode transmitir dados de pedidos e ao mesmo
tempo fazer a gestão de novos pedidos. As threads podem ainda ser utilizadas
cooperativamente, por exemplo, uma thread pode efectuar um determinado cálculo
auxiliar retornando o resultado desse cálculo para que outra thread possa usar esse
resultado na sua execução, sendo isto possível de fazer “simultaneamente”.
possível fazer o tipo de programas dados como exemplo sem usar threads, usando
“esquemas” de interrupções e/ou de pooling, mas isso implica uma maior complexidade
de programação e uma difícil manutenção. Muitos problemas de software podem ser
resolvidos e até evitados, recorrendo ao uso de multiprogramação. Em Java estão
disponibilizadas as threads que permitem a multiprogramação.
Como se usam threads?
As threads em java estão definidas na classe Thread da biblioteca standart de Java.
Podemos criar uma thread de duas formas, uma é criando um objecto thread (Thread t =
new Thread();), de seguida configurar a thread colocando a prioridade inicial e o nome, e
por fim invocando o método start(). Este método inicia a execução da thread e só pode
ser executado uma vez, lançando uma excepção se for executado mais que uma vez, na
mesma thread. Após a execução do método start() a máquina virtual Java invoca o
método run() da thread tornando a thread activa até que o método retorne algo,
terminando a thread. Este método da classe Thread não faz nada, pelo que tem de ser
reescrito, sendo por isso necessário fazer uma subclasse de Thread, em que o método
run() esteja definido.
A outra forma de criar uma thread é criar um objecto que implemente a interface
runnable(definindo o método run()) e passando esse objecto ao construtor da classe
Thread.
Uma classe que seja subclasse da classe Thread, herda os seguintes métodos:
start() - inicia a execução da thread;
stop() - pára a execução da thread;
suspend() - pára a thread temporariamente;
resume() - retoma a execução da thread;
sleep(t) – para a execução da thread durante t milisegundos;
run() - método que é o corpo da thread.
Alguns destes métodos já tinham sido referidos anteriormente, o método run() é o método
que descreve o que a thread faz, tendo por isso de ser reescrito sempre, como já foi
referido anteriormente
Como partilhar objectos usando threads?
Assim como podem efectuar tarefas independentes, as threads também podem ser usadas
cooperativamente, isto é, duas threads podem efectuar operações sobre o mesmo objecto,
existindo então a possibilidade de haver corrupção de dados, por exemplo uma thread
efectua uma leitura e outra efectua efectua uma escrita ao mesmo tempo,por isso, e para
evitar que tal aconteça a linguagem Java disponibiliza uma forma para sincronizar o
acesso de várias threads a um objecto. A forma de sincronizar em Java é declarando os
métodos que alterem o estado do objecto como “syncronized”, ou utilizando a instrução
syncronized(), e funciona da seguinte forma, quando uma thread tenta aceder a um
objecto verifica se este está “locked”(fechado), se não estiver coloca um “lock”(fecho) e
faz o que tem a fazer, se o objecto estiver “locked” a thread fica suspensa até que o
objecto deixe de estar “locked”. Isto funciona como um mecanismo de exclusão mútua
usado em várias aplicações e em especial, em sistemas operativos. Este tipo de
mecanismo tem um claro interesse para aplicações do tipo cliente-servidor, em que o
servidor pode ser acedido por vários clientes.
Exemplos
Exemplo 1: Threads usando subclasses de Thread
public class countingThread1 extends Thread
{
private int start;
private int finish;
public countingThread1(int from, int to)
{
this.start = from;
this.finish = to;
public void run()
{
for (int i = start; i <= finish; i++)
{
System.out.print (i + " ");
}
Resultado da execução:
1 20 21 22 23 24 25 26 27 28 29 30 2 3 4 5 6 7 8 9 10
Exemplo 2: Threads usando implementação de Runnable
public class countingThread2 implements Runnable
{
private int start;
private int finish;
public countingThread2(int from, int to)
{
this.start = from;
this.finish = to;
public void run()
{
for (int i = start; i <= finish; i++) {
System.out.print (i + " ");
}
Resultado da execução:
1 20 21 22 23 24 25 26 27 28 29 30 2 3 4 5 6 7 8 9 10
Exemplo 3: Threads com sincronização
public class Swapper
{
int from;
int to;
public syncronized void swap()
{
int temp = from;
from = to;
to = temp;
}
}
Análise dos resultados
Por limitações de espaço não é possível obter vários resultados de execução, mas
copiando o código e fazendo-o correr pode verificar-se que os resultados mudam. Estes
exemplos são muito simples, apenas mostrando uma pequena parte das possibilidades do
uso de threads, pelo que é aconselhável mais investigação nesta área para uma melhor
compreensão das reais capacidades deste tipo de programação. O exemplo 3 não tem
resultados, pois procura apenas mostrar o uso da palavra-chave “syncronized”.
Conclusão
As threads são uma forma de multiprogramação, com grandes capacidades, permitindo ao
programador utiliza-las para melhorar as suas aplicações, quer em performance, quer em
segurança. As threads podem ainda se usadas de outras formas, pelo que é aconselhado
investigar e “investir” nesta área para realmente perceber as capacidades das threads
Bibliografia
Sebenta de Linguagens e Programação II, Fernando Mouta
Java Tuturial
Borland Jbuilder help