Olá, hoje aprenderemos sobre a interface Runnable, entre outras utilidades com ela poderemos implementar um código mais enxuto, separando as partes. E mais importante para nós em Java, poderemos trabalhar com objetos. Visto que dá forma como implementamos as threads nos dois últimos tutorias não é possível instanciá-la como fazemos com os objetos. Ou seja, não sendo possível trabalhar com a thread em outros locais.

Dessa forma, a interface Runnable é essencial em termos de implementação de objetos que serão executados de forma encadeada. É interessante, pois ela define um único método run(), e como sabemos, trata-se do método responsável pela execução dos códigos, neste caso dos códigos encadeados.

Temos implementadas duas threads, simulando respectivamente rotinas de envios de e-mail e nota fiscal. Ambas apresentam a mesma estrutura. Isto é, uma new thread seguida da instrução .start(), responsável por ligar a thread ao código que será processado em segundo plano.

New Thread(){
}.start();

No corpo das threads implementamos a rotina de envio de e-mai em uma e de envio de nota fiscal na segunda, porém, as duas rotinas são cada uma implementada dentro do seu próprio método run(). Ele será o responsável pelo disparo das rotinas, pela execução delas.

public void run(){
     for(){
     }
}

Porém cada uma dessas rotinas no laço for traz implementada dentro de um try/catch a thread sleep, que determina o tempo de resposta para o envio de cada uma. 

try {
   Thread.sleep(2000);
}catch(InterruptedException e){
   e.printStackTrace();
}

O ponto interessante é que como se trata da implementação de duas threads poderíamos ter a situação em que uma thread demoraria um pouco mais em sua execução do que a outra. Neste caso, a thread concorrente assumiria o lugar, é o que chamamos de processamento em paralelo e concorrente.

IMPLEMENTANDO O RUNNABLE

Então, fora do método principal, no final do código iremos implementar a interface Runnable. Ela terá visibilidade privada, pois será visível somente dentro da classe. Seguindo a interface Runnable definiremos uma variável thread1 que receberá a instancia de um runnable, que automaticamente implementará o método run().

private static Runnable thread1 = new Runnable(){
   public void run(){
   }
};

Agora copiaremos dentro do run(), todo o código que simula a rotina de envio de e-mail. Feito isso apagaremos o código que ficou deixando tão somente o new Thread. Porque é a partir dela que iremos chamar a thread1. Observe que a thread apresenta agora alguns construtores, entre os quais Runnable.

Clique sobre o construtor Runnable, assim, dessa forma poderemos chamar a thread1. O que nos permitirá trabalhar com ela como um objeto.

Thread threadEmail = new Thread (thread1);
threadEmail.start();

E assim, poderemos além de dar o start, destruir, ver se a thread está ativa, pará-la, enfim, inúmeras possiblidades.

Para implementarmos a thread que simula o envio de notas fiscais, procederemos da mesma forma. Porém distinguindo um método do outro a partir do nome da variável, neste caso a chamaremos de thread2.

Thread threadNotaFiscal = new Thread(thread2);
threadEnvioNF.start();

Ao executarmos o resultado idêntico ao da implementação anterior, a diferença é que agora estamos trabalhando as threads como sendo objetos manipuláveis.

EM POUCAS PALAVRAS

A grande vantagem de utilizarmos a interface Runnable é justamente a possiblidade de transformas a threads em objetos manipuláveis. O que amplia e muito as nossas possibilidades, e nos permite explorar diferentes recursos das threads. Espero que tenham gostado, eu fico por aqui, nos vemos nos próximos tutoriais.