Hoje abordaremos um pouco sobre as Threads.
Este tema é bastante assustador para alguns desenvolvedores, mas em contrapartida outros não "vivem sem". (eu vivo, rsrsrs).
Bom, vamos partir do ponto, O que são threads?
Threads, ou linha de execução, nada mais é que, a forma de um processo se dividir em duas ou mais tarefas, fazendo parecer que seu programa está executando mais de uma linha de comando simultaneamente.
Uma boa 'ilustração' das Threads pode ser: Um programa que inicie uma linha de execução para verificar a ortografia de um texto, enquanto uma segunda capture o texto digitado e já faça a devida validação do mesmo.
Mas Threads são tão importantes assim?
Imagine o seguinte cenário: Está você bem respondendo aquele importantíssimo email do seu chefe, agradecendo o tão esperado reajuste salarial, e você para no 78ª linha do email, e clica em no Menu Editar, do seu Browser...
Possivelmente, o que poderia acontecer? rsrsrs, seu navegado parar de responder.....
Na historinha contada acima, ilustra a importância das Threas em interfaces gráficas, mas elas podem aparecer em diversos outro lugares, como em sistemas multiprocessados.
Tudo bem, e como poderíamos criar uma Thread?
Bom, há duas formas de criarmos um thread em java:
1 - Estendendo a classe Thead
2 - Implementando a interface Runnable.
Segue um pequeno exemplo:
//Estendendo a classe Thread
public class MinhaThread extends Thread {
public MinhaThread(){}
//reescrevendo o metodo run()
public void run() {
System.out.println("Thread Executada");
}
}
class TestaThread{
public static void main(String[] args) {
MinhaThread mt = new MinhaThread();
MinhaThread mt1 = new MinhaThread();
MinhaThread mt2 = new MinhaThread();
MinhaThread mt3 = new MinhaThread();
mt.start();
mt1.start();
mt2.start();
mt3.start();
}
}
//Exemplo implementando a interface Runnable
public class MinhaThread implements Runnable {
public void run() {
System.err.println("Executado. Implementando a Interface Runnable");
}
}
class TestaThread{
public static void main(String[] args) {
MinhaThread mt = new MinhaThread();
MinhaThread mt1 = new MinhaThread();
Thread t = new Thread(mt);
Thread t1 = new Thread(mt1);
t.start();
t1.start();
}
}
Acima fizemos dois exemplos simples de criação das nossas Threads.
É interessante sabermos também, até quando uma Thread fica "viva", ou seja, como é seu ciclo de vida.
Vamos dar uma pequena "pincelada", dos estados que ela pode assumir.
1 - Cria Thread
2 - Inicia Thread (start())
o início é dado pelo método start();
Este aciona o método run();
O estado da Thread neste momento estará Runnable
3 - Executando (run())
((Estados que podem assumir))
3.1 - Dorme
3.2 - Acorda
3.3 - Suspende
3.4 - Retorna
3.5 - Espera
3.6 - Notifica
3.7 - Bloqueio
3.8 - Desbloqueio
Os estados acima, podem acontecer se a Thread estiver Bloqueada.
4 - Finalizada.
Até o momento, já temos uma boa noção do que são Threads, como criá-las, e como elas podem se comportar.
Vejamos agora alguns métodos importantíssimos.
Bloqueando um Thread: ela entra neste estado, quando:
- o método sleep é chamado,
neste metodo você pode passar o tempo que ela deve ficar bloqueada.
- a Thread chama o método wait
fica neste estado, até que outro objeto notifica (notify ou notifyAll).
Parando um Thread:
Uma Thread tem estado "viva" até que suas condições tenham sido todas aceitas, ou seja, quando o método run() termina.
Mas existem métodos que podem forçar esta parada: destroy() ou stop().
Método isAlive():
Este método retorna true, se a Thread foi iniciada e ainda não parou, e false, se ela está no estado New thread ou Dead.
Bom, a idéia central deste post foi dar apenas os primeiros passos na criação e utilização das Threads,
nos próximos capítulos deste assunto, iremos focar mais em pontos específicos das tão temidas Threads.
Espero ter contribuído.
Nenhum comentário:
Postar um comentário