JAVA: Criando Threads

Podemos fazer analogia a um processo como sendo um programa em execução. Já uma Thread é conhecida como "processo leve" (lightweight process), é considerada leve pelo fato de rodar dentro do contexto do processo, aproveitando-se do compartilhamento dos recursos alocados para o ambiente do programa.

Há casos em que dentro da execução de um processo, verifica-se a necessidade de "disparar" uma thread que irá executar paralelamente ao processo a que pertence. Dessa forma, pode-se executar instruções sem que o processo principal fique em estado de espera "lock" até que um trecho de código seja executado.

Em JAVA pode-se herdar a classe Thread ou implementar a interface Runnable para se utilizar threads em seus processos. Exemplo de uma thread simples:

/**
*
* @author João Paulo Eiti Kimura Classe que estende uma tread simples
*/
public class SimpleThread extends Thread {

public SimpleThread(String str) {
super(str);
}

public void run() {

// qualquer processamento ...

// faz a thread dormir um número aleatório em (ms)
long sleepTime = (long) (Math.random() * 1000);
System.out.println(getName() + " sleeping for " + sleepTime + " ms");

try {
sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("finished: " + getName()); // finaliza a execuçao
}
}

No exemplo da classe SimpleThread, pode-se verificar que a classe herda características da classe Thread do java. Seu construtor default chama o construtor da classe mãe (Thread), no qual o parâmetro passado representa o nome da thread. O método principal da thread é o run, é nele que todo processamento é realizado. Com fins ilustrativos, o método run desse exemplo apenas aguarda um tempo em milissegundos.

Vejamos como executar a classe SimpleThread:

public class ExemploThread {

public static void main(String[] args) {

SimpleThread t1 = new SimpleThread("Thread 1");
SimpleThread t2 = new SimpleThread("Thread 2");
SimpleThread t3 = new SimpleThread("Thread 3");

t1.start();
t2.start();
t3.start();
}
}

Na classe ExamploThread, foram instanciados 3 objetos das classe SimpleThread. Para iniciar a execução da thread, fez-se a chamada ao método start() de cada objeto. Esse método executa o método run implementado na thread.
Resultado da execução da classe ExemploThread:

Thread 1 sleeping for 546 ms
Thread 3 sleeping for 580 ms
Thread 2 sleeping for 854 ms
finished: Thread 1
finished: Thread 3
finished: Thread 2

Dessa forma é possível executar tarefas em paralelo ao processo principal de um programa. Entretando, se sua classe já tiver herdado alguma outra classe não será possível herdar a classe Thread, ou qualquer outra, devido a natureza da linguagem que permite a herdar as características de apenas 1 classe. Especificamente para solucionar esse caso, faz-se uso da implementação da interface Runnable.

A classe que implementar a interface Runnable irá implementar o método run. Vamos a um exemplo de implementação desta interface:

public class ThreadInterface extends MyClass implements Runnable {

public void run() {

// qualquer processamento ...

// faz a thread dormir um número aleatório em (ms)
long sleepTime = (long) (Math.random() * 1000);
System.out.println(Thread.currentThread().getName() + "Thread sleeping for " + sleepTime + " ms");

try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("finished: " + Thread.currentThread().getName()); // finaliza a execuçao
}
}

Um exemplo de chamada e execução da classe que implementa a interface Runnable:

public class ExemploThreadInterface {

public static void main(String[] args) {

new Thread(new ThreadInterface(), "Thread1").start();
new Thread(new ThreadInterface(), "Thread2").start();
new Thread(new ThreadInterface(), "Thread3").start();
}
}

Resultado da execução:

Thread1Thread sleeping for 569 ms
Thread3Thread sleeping for 821 ms
Thread2Thread sleeping for 795 ms
finished: Thread1
finished: Thread2
finished: Thread3

Com a classe Thread e a interface Runnable é possível criar facilmente threads simples em Java, de forma a executar tarefas na execução de qualquer processo da aplicação.

Download dos códigos fonte dos exemplos: thread_src.zip