Criação de thread e Runnables

As implementação Runnable que vimos no primeiro artigo foram inline. Ou seja, nós não usamos a declaração de uma classe. Podemos fazer isto da seguinte maneira:

   public class MyTask implements Runnable {
        public void run() {
          ...
        }
   }
      ...
      Runnable r = new MyTask();
      Thread thr = new Thread(r);

Se escrevêssemos new Runnable(), o compilador na verdade acaba criamos um “dummy class” para nós. No nosso exemplo do primeiro artigo tínhamos dois Runnable com códigos semelhantes, apenas uma mensagem em um intervalo de tempo, neste caso será mais limpo  se definíssemos uma classe que recebe a mensagem e o intervalo como parâmetro para o construtor:

  public class MessagePrinter implements Runnable {
        private final String message;
        private final long interval;
        public MessagePrinter(String msg, long interval) {
              this.message = msg;
              this.interval = interval;
        }
        public void run(){
              try {
                    while (true) {
                          System.out.println(message);
                          Thread.sleep(interval);
                          }
                    } catch (InterruptedException iex) {}
       }
  }

Observe que declaramos  as variáveis como final. Fazemos isto basicamente para ter certeza que elas serão vistas corretamente pelas duas thread envolvidas (a thread que constrói o objeto e a thread que é construía na hora que o método run() é executado).

Segundo padrão: sobrecarga (override) da Thread.run()

A classe Thread tem um método run()(normalmente vazio). Se você não atribuir um Runnable para o construtor da Thread, o métodorun() será chamado toda vez que a thread é iniciada. Então nós poderíamos escrever algo assim:

  public void MyThread extends Thread {
        public void run() {
          ...
        }
  }
      ...
      Thread thr = new MyThread();
      thr.start();

Claro, também podemos transformar isso em uma classe de uma linha:

            Thread thr = new Thread() {
                    public void run() {
                      ...
                    }
                  }
                  thr.start();

Qual é o padrão de criação de Thread?

Então, qual o método que você deve usar para criar um thread em Java? Em geral, a criação de umRunnable separado dá mais flexibilidade. Porque executar em uma thread, não é a única forma de executar um Runnable, por isto, se você atribuir tudo em um objeto Thread, pode necessitar em outro momento que o código seja executado de outra forma, neste caso você terá mais trabalho se criar tudo em diretamente no objeto Thread. No caso mais simples, um Runnable separado permite-lhe escrever algo como o seguinte:

      public void runTask(Runnable r, boolean separateThread) {
            if (separateThread) {
                  (new Thread(r)).start();
            } else {
                  r.run();
            }
      }

Outros exemplos onde um Runnable é usado estão com o método Swing.invokeLater() (o Swing pode pedir para a thread principal executar uma tarefa), ou com outras utilizadas no pacote Java 5.

Por outro lado, existe momento que as threads não devem ser criadas em um objeto Runnableseparado, e substituindo o método Thread.run() pode ser uma forma de deixar o seu código mais legível.

Fonte: http://www.treinaweb.com.br/ler-artigo/27/criacao-de-thread-e-runnables