“Implementa Runnable” vs “estende Thread” em Java

https://stackoverflow.com/questions/541487

23-08-2019
|

Pergunta

A partir do que tempo que passei com threads em Java, eu encontrei estas duas maneiras de tópicos de escrita:

Com implements Runnable:

public class MyRunnable implements Runnable {
    public void run() {
        //Code
    }
}
//Started with a "new Thread(new MyRunnable()).start()" call

Ou, com extends Thread:

public class MyThread extends Thread {
    public MyThread() {
        super("MyThread");
    }
    public void run() {
        //Code
    }
}
//Started with a "new MyThread().start()" call

Existe alguma diferença significativa nestes dois blocos de código?

Solução

Sim: implementos Runnable é a forma preferida para fazer isso, IMO. Você não está realmente especializada comportamento do segmento. Você está apenas dando-lhe algo para ser executado. Isso significa composição é a filosoficamente "mais puro" caminho a percorrer.

Em prática termos, isso significa que você pode implementar Runnable e estender de outra classe também.

Outras dicas

Em Suma: implementos Runnable é melhor. No entanto, a ressalva é importante

Em geral, eu recomendo usar algo como Runnable em vez de Thread porque ele permite que você mantenha o seu trabalho apenas vagamente juntamente com sua escolha de concorrência. Por exemplo, se você usar um Runnable e decidir mais tarde que este na verdade não requer é próprio Thread, você pode apenas chamar threadA.run ().

Aviso: Por aqui, eu fortemente desencorajar o uso de linhas cruas. Eu prefiro muito mais o uso de Callables FutureTasks (do javadoc: "A computação assíncrona canceláveis"). A integração dos tempos de espera, o cancelamento adequada e o pool de segmentos do suporte a concorrência moderna são muito mais útil para mim do que pilhas de linhas cruas.

Follow-up: há um FutureTask construtor que permite que você use Runnables (se é isso que você está mais confortável com) e ainda obter o benefício das ferramentas de simultaneidade modernos . Para citar o javadoc :

Se você não precisa de um resultado particular, considerar o uso de construções da forma:

Future<?> f = new FutureTask<Object>(runnable, null)

Então, se substituirmos a sua runnable com o seu threadA, temos o seguinte:

new FutureTask<Object>(threadA, null)

Outra opção que lhe permite ficar mais perto de Runnables é um ThreadPoolExecutor . Você pode usar o executar método para passar em um Runnable para executar 'o dado algum trabalho no futuro'.

Se você gostaria de tentar usar um pool de threads, o fragmento de código acima iria se tornar algo como o seguinte (usando o Executors.newCachedThreadPool () método de fábrica):

ExecutorService es = Executors.newCachedThreadPool();
es.execute(new ThreadA());

Moral da história:

Inherit somente se você deseja substituir alguns comportamentos.

Ou melhor, deve ser lido como:

Inherit menos, interface mais.

Bem tantas boas respostas, eu quero adicionar mais sobre isso. Isso vai ajudar a entender Extending v/s Implementing Thread.
Estende liga dois arquivos de classe de muito perto e pode causar algum bem difícil de se lidar com o código.

As duas abordagens fazer o mesmo trabalho, mas tem havido algumas diferenças.
A diferença mais comum é

Quando você estender a classe Thread, depois que você não pode estender qualquer outra classe que você necessário. (Como você sabe, Java não permite herdar mais de uma classe).
Quando você implementa Runnable, você pode economizar espaço para a sua classe para estender qualquer outra classe no futuro ou agora.

No entanto, um diferença significativa entre implementar Runnable e estendendo Tópico é que
by extending Thread, each of your threads has a unique object associated with it, whereas implementing Runnable, many threads can share the same object instance.

O exemplo a seguir irá ajudá-lo a entender mais claramente

//Implement Runnable Interface...
 class ImplementsRunnable implements Runnable {

private int counter = 0;

public void run() {
    counter++;
    System.out.println("ImplementsRunnable : Counter : " + counter);
 }
}

//Extend Thread class...
class ExtendsThread extends Thread {

private int counter = 0;

public void run() {
    counter++;
    System.out.println("ExtendsThread : Counter : " + counter);
 }
}

//Use the above classes here in main to understand the differences more clearly...
public class ThreadVsRunnable {

public static void main(String args[]) throws Exception {
    // Multiple threads share the same object.
    ImplementsRunnable rc = new ImplementsRunnable();
    Thread t1 = new Thread(rc);
    t1.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    Thread t2 = new Thread(rc);
    t2.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    Thread t3 = new Thread(rc);
    t3.start();

    // Creating new instance for every thread access.
    ExtendsThread tc1 = new ExtendsThread();
    tc1.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    ExtendsThread tc2 = new ExtendsThread();
    tc2.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    ExtendsThread tc3 = new ExtendsThread();
    tc3.start();
 }
}

saída do programa acima.

ImplementsRunnable : Counter : 1
ImplementsRunnable : Counter : 2
ImplementsRunnable : Counter : 3
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1

Na abordagem interface Runnable, apenas uma instância de uma classe está sendo criada e tem sido compartilhada por diferentes threads. Portanto, o valor do contador é incrementado para cada acesso fio.

Considerando que, abordagem de classe Thread, você deve ter para criar instância separada para cada acesso rosca. Daí memória diferente é alocado para cada instâncias de classe e cada um tem balcão separado, o valor permanece o mesmo, o que significa que não há incremento vai acontecer porque nenhum da referência do objeto é o mesmo.

Quando usar Runnable?
Use interface Runnable quando você deseja acessar os mesmos recursos do grupo de threads. Evitar o uso de classe Thread aqui, porque consome criação de vários objetos mais memória e torna-se uma grande sobrecarga de desempenho.

Uma classe que implementa Runnable não é um fio e apenas uma classe. Para um Runnable para se tornar um tópico, você precisa criar uma instância de Thread e passando-se em como o destino.

Na maioria dos casos, a interface Runnable deve ser usado se você só está planejando para substituir o método run() e há outros métodos de Tópicos. Isto é importante porque as classes não deve ser uma subclasse a menos que o programador tem a intenção de modificar ou melhorar o comportamento fundamental da classe.

Quando há uma necessidade de estender uma superclasse, implementando a interface Runnable é mais apropriado do que usando a classe Thread. Porque podemos estender outra classe ao implementar interface Runnable para fazer um fio.

Espero que isso vai ajudar!

Uma coisa que eu estou surpreendido ainda não foi mencionado é que a implementação Runnable faz sua classe mais flexível.

Se você estender fio, em seguida, a ação que você está fazendo é sempre vai ser em um fio. No entanto, se você implementar Runnable ele não tem que ser. Você pode executá-lo em um segmento, ou passá-lo para algum tipo de serviço executor, ou apenas passá-lo em torno de como uma tarefa dentro de uma única aplicação de rosca (talvez para ser executado em um momento posterior, mas dentro do mesmo segmento). As opções são muito mais aberta se você usar apenas Runnable do que se você ligar-se a Thread.

Se você quiser implementos ou estende qualquer outra classe, em seguida, interface de Runnable é mais preferível, caso contrário, se você não quer qualquer outra classe para estender ou implementar, em seguida, classe Thread é preferível.

A diferença mais comum é

enter descrição da imagem aqui

Quando você extends Thread classe, depois que você não pode estender qualquer outra classe que você necessário. (Como você sabe, Java não permite herdar mais de uma classe).

Quando você implements Runnable, você pode economizar espaço para a sua classe para estender qualquer outra classe no futuro ou agora.

Java não suporta múltiplas heranças, o que significa que você só pode estender uma classe em Java assim uma vez que você estendeu classe Thread você perdeu sua chance e não pode estender ou herdar outra classe em Java.
Na programação orientada para o objecto, estendendo-se uma classe geral meio, a adição de novas funcionalidades, e modificar ou melhorar comportamentos. Se não estamos fazendo qualquer modificação no tópico então usar a interface Runnable em vez.
interface Runnable representa uma tarefa que pode ser executada por qualquer fio simples ou executores ou qualquer outro meio. separação de modo lógico de tarefas como Runnable de linha é uma boa decisão de design.
tarefa de separação como Runnable significa que podemos reutilizar a tarefa e também tem a liberdade de executá-lo a partir de diferentes meios. desde que você não pode reiniciar um segmento, uma vez que ela seja concluída. novamente Runnable vs Tópico para a tarefa, Runnable é vencedor.
designer de Java reconhece isso e é por isso executores aceitam Runnable como tarefa e eles têm segmento de trabalho que executa as tarefas.
Herdando todos os métodos de Tópicos são sobrecarga adicional apenas para representar uma tarefa que pode ser feito facilmente com Runnable.

Cortesia de javarevisited.blogspot.com

Estas foram algumas das diferenças notáveis ??entre o fio e Runnable em Java. Se você conhece algum outras diferenças em Tópico vs Runnable do que por favor partilhe-lo através de comentários. Eu pessoalmente uso Runnable ao longo da linha para este cenário e recomenda usar Runnable ou interface Callable com base em sua exigência.

No entanto, a diferença significativa é.

Quando você extends Thread classe, cada um de seu segmento cria um objeto único e associado com ele. Quando você implements Runnable, ele compartilha o mesmo objeto para vários segmentos.

Na verdade, não é sábio comparar Runnable e Thread uns com os outros.

Este dois têm uma dependência e relação em multi-enfiar apenas como relacionamento Wheel and Engine de veículo a motor.

Eu diria, há apenas um caminho para multi-threading com duas etapas. Deixe-me fazer o meu ponto.

Runnable:
Ao implementar interface Runnable significa que você está criando algo que é run able em um segmento diferente. Agora a criação de algo que pode ser executado dentro de uma thread (executável dentro de um segmento), não significa a criação de uma Thread.
Assim, o MyRunnable classe é nada mais que uma classe ordinária com um método void run. E é objetos serão alguns objetos comuns com apenas um run método que irá executar normalmente quando chamado. (A menos que passar o objeto em um thread).

Tópico:
class Thread, eu diria Uma classe muito especial com a capacidade de iniciar uma nova discussão que realmente permite multi-threading através de seu método start().

Por que não é sábio para comparar?
Porque precisamos de ambos para multi-threading.

Para multi-threading, precisamos de duas coisas:

Algo que pode ser executado dentro de uma Thread (Runnable).
algo que pode iniciar um novo Thread (Thread).

Então, tecnicamente e teoricamente ambos é necessário iniciar uma discussão, um vai Executar e um vai fazê-lo correr (como Wheel and Engine de veículo a motor).

É por isso que você não pode iniciar uma discussão com MyRunnable você precisa passá-lo para uma instância de Thread.

Mas é possível criar e executar um fio usando apenas class Thread porque implementos Thread Classe Runnable para que todos Thread saber também um dentro Runnable.

Finalmente Thread e Runnable são complemento uns aos outros para multithreading não concorrente ou substituição.

Você deve implementar Runnable, mas se você estiver executando em Java 5 ou superior, você não deve começar com new Thread mas usar um ExecutorService . Para mais detalhes ver: Como implementar rosca simples em Java

Eu não sou um especialista, mas eu posso pensar em uma razão para implementar Runnable em vez de estender Tópico:. Java suporta apenas herança simples, assim você só pode estender uma classe

Edit: Esta originalmente disse: "A implementação de uma interface requer menos recursos." bem, mas você precisa criar uma nova instância da linha de qualquer forma, então isso foi errado.

Eu diria que há uma terceira via:

public class Something {

    public void justAnotherMethod() { ... }

}

new Thread(new Runnable() {
   public void run() {
    instanceOfSomething.justAnotherMethod();
   }
}).start();

Talvez esta é influenciada um pouco pelo meu uso pesado recente Javascript e ActionScript 3, mas desta forma a sua classe não precisa implementar uma interface muito vago como Runnable.

Com o lançamento do Java 8, agora há uma terceira opção.

Runnable é um interface funcional, que significa que as instâncias de que podem ser criados com expressões lambda ou referências método.

O seu exemplo pode ser substituída por:

new Thread(() -> { /* Code here */ }).start()

ou se você quiser usar um ExecutorService e uma referência de método:

executor.execute(runner::run)

Estes não são apenas muito mais curto do que seus exemplos, mas também vêm com muitas das vantagens estabelecidas em outras respostas de usar Runnable sobre Thread, como única responsabilidade e usando composição porque você não está especializada comportamento do segmento. Desta forma, também evita a criação de uma classe extra se tudo que você precisa é de um Runnable como você faz em seus exemplos.

Instanciando uma interface dá uma separação mais clara entre o código ea implementação de threads, então eu prefiro implementar Runnable neste caso.

Todo mundo aqui parece pensar que Runnable implementação é o caminho a percorrer e eu realmente não concordar com eles, mas também há um caso para a extensão da linha, na minha opinião, na verdade você tem sorte do demonstrou em seu código.

Se você implementar Runnable, em seguida, a classe que implementa Runnable não tem controle sobre o nome da linha, que é o código de chamada que podem definir o nome do segmento, assim:

new Thread(myRunnable,"WhateverNameiFeelLike");

mas se você estender Passe então você começa a gerenciar isso dentro da própria classe (assim como no seu exemplo você nomeia o segmento 'ThreadB'). Neste caso, você:

A) pode dar-lhe um nome mais útil para fins de depuração

B) estão forçando que esse nome seja usado para todas as instâncias dessa classe (a menos que você ignorar o fato de que é um fio e fazer o descrito acima com ele como se fosse um Runnable, mas estamos falando de convenções aqui em qualquer caso assim se pode ignorar essa possibilidade eu sinto).

Você pode até, por exemplo, tomar um rastreamento de pilha de sua criação e utilização que, como o nome de rosca. Isso pode parecer estranho, mas dependendo de como o código é estruturado que pode ser muito útil para fins de depuração.

Esta pode parecer uma coisa pequena, mas onde você tem uma aplicação muito complexa com um monte de tópicos e todos repente as coisas 'pararam' (seja por razões de impasse ou possivelmente por causa de uma falha em um protocolo de rede que seria menos óbvio - ou por outras razões infinitas), em seguida, obter um despejo de pilha de Java, onde todos os tópicos são chamados 'thread-1', 'thread-2', 'thread-3' nem sempre é muito útil (que depende de como seus tópicos são estruturados e se você pode ser útil para dizer qual é qual apenas pelo seu rastreamento de pilha -. nem sempre é possível se você estiver usando grupos de vários segmentos tudo que executam o mesmo código)

Dito isto, você poderia, claro, também fazer o acima de uma forma genérica, criando uma extensão da classe discussão que define o seu nome a um rastreamento de pilha de seu apelo criação e depois usar isso com suas implementações Runnable em vez do padrão classe java thread (veja abaixo), mas, além do rastreamento de pilha pode haver mais informações contexto específico que seria útil em nome thread para depuração (uma referência a uma das muitas filas ou soquetes que poderia processar, por exemplo, no caso de você que pode preferir estender Tópico especificamente para esse caso, para que você pode ter a força de compilador que você (ou outras pessoas usando suas bibliotecas) para passar em certas informações (por exemplo, a fila / socket em questão) para uso no nome).

Aqui está um exemplo do segmento genérico com o rastreamento de pilha chamar como seu nome:

public class DebuggableThread extends Thread {
    private static String getStackTrace(String name) {
        Throwable t= new Throwable("DebuggableThread-"+name);
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(os);
        t.printStackTrace(ps);
        return os.toString();
    }

    public DebuggableThread(String name) {
        super(getStackTrace(name));
    }

    public static void main(String[] args) throws Exception {
        System.out.println(new Thread());
        System.out.println(new DebuggableThread("MainTest"));
    }
}

e aqui está um exemplo do resultado da comparação dos dois nomes:

Thread[Thread-1,5,main]
Thread[java.lang.Throwable: DebuggableThread-MainTest
    at DebuggableThread.getStackTrace(DebuggableThread.java:6)
    at DebuggableThread.<init>(DebuggableThread.java:14)
    at DebuggableThread.main(DebuggableThread.java:19)
,5,main]

Runnable porque:

As folhas mais flexibilidade para o implementação Runnable para estender outra classe
separa o código de execução
Permite que você execute o seu executável a partir de um segmento de pool, o segmento de eventos, ou em qualquer outra forma o futuro.

Mesmo que você não precisa de nada disso agora, você pode no futuro. Desde que não há nenhum benefício para substituir Thread, Runnable é uma solução melhor.

Uma vez que este é um tema muito popular e as boas respostas estão espalhados por todo e tratadas em grande profundidade, senti que é justificável para compilar as boas respostas dos outros em uma forma mais concisa, para que os recém-chegados têm uma visão geral fácil inicial:

Você costuma estender uma classe para adicionar ou modificar a funcionalidade. Então, se você não quer para sobrescrever qualquer comportamento Tópico , em seguida, usar Runnable.
Na mesma luz, se você não precisa para herdar métodos de rosca, você pode fazer sem que sobrecarga por usando Runnable.
herança Single :. Se você estender segmento que você não pode se estender de qualquer outra classe, por isso, se é isso que você precisa fazer, você tem que usar Runnable
É bom design de lógica de domínio separado de meios técnicos, nesse sentido, é melhor ter uma tarefa Runnable isolamento o tarefa o corredor .
Você pode Executar o mesmo Runnable objeto várias vezes , um objeto Thread, no entanto, só pode ser iniciado imediatamente. (Talvez a razão, porque Executores não aceitamos Runnables, mas não Threads.)
Se você desenvolver sua tarefa como Runnable, você tem toda a flexibilidade como usá-lo agora e no futuro . Você pode tê-lo executado simultaneamente via executores, mas também através de Thread. E você ainda poderia também usar / chamá-lo não simultaneamente dentro do mesmo segmento, assim como qualquer outro tipo / objeto comum.
Isto torna também mais fácil de tarefa de lógica e de simultaneidade separado aspectos seus testes unidade .
Se você está interessado nesta questão, que você pode ser também interessado na diferença entre mobilizável e Runnable.

Diferença entre Estendendo Rosca e implementando Runnable são:

Isto é discutido em Definição da Oracle e iniciar um thread tutorial:

Qual destas expressões idiomáticas que você deve usar? O primeiro idioma, que emprega um objeto Runnable, é mais geral, porque a lata objeto Runnable subclasse uma classe diferente de Thread. O segundo idioma é mais fácil de usar em aplicações simples, mas é limitado pelo fato de que sua tarefa classe deve ser um descendente de Thread. Esta lição se concentra no primeiro abordagem, que separa a tarefa Runnable do objeto Thread que executa a tarefa. Não só é esta abordagem mais flexível, mas é aplicável às APIs de gestão de fio de alto nível cobertos mais tarde.

Em outras palavras, a implementação Runnable vai trabalhar em cenários onde a sua classe estende uma classe diferente de Thread. Java não suporta herança múltipla. Além disso, estendendo Thread não será possível ao usar algumas das APIs de gerenciamento de fio de alto nível. O único cenário onde estendendo Thread é preferível está em uma pequena aplicação que não estará sujeito a atualizações no futuro. É quase sempre melhor para implementar Runnable como é mais flexível que o seu projeto cresce. A alteração de design não terá um grande impacto como você pode implementar muitas interfaces em Java, mas apenas estender uma classe.

Se não estou errado, é mais ou menos semelhante ao

Qual é a diferença entre uma interface e classe abstrata?

estende estabelece " é um " relação e interface fornece " Tem um " capacidade.

Prefere implementa Runnable :

Se você não tem que estender classe Thread e modificar implementação padrão API Tópico
Se você está executando um incêndio e comando esquecer
Se você já está estendendo outra classe

Prefere " estende Thread ":

Se você tiver que substituir qualquer um destes Tópico métodos conforme listado na página de documentação do oracle

Geralmente você não precisa comportamento override Thread. Então implementa Runnable é o preferido para a maioria das vezes.

Em uma nota diferente, usando ExecutorService avançado ou ThreadPoolExecutorService API fornece mais flexibilidade e controle.

Tenha um olhar para este SE Pergunta:

ExecutorService vs Linha Casual Spawner

A explicação mais simples seria através da implementação de Runnable podemos atribuir o mesmo objeto para vários segmentos e cada Thread ações os mesmos estados de objeto e de comportamento.

Por exemplo, suponha que existem dois tópicos, thread1 puts um inteiro em uma matriz e thread2 leva inteiros a partir da matriz quando a matriz é preenchida. Observe que, a fim de thread2 para trabalhar ele precisa saber o estado da matriz, se thread1 encheu-lo ou não.

Implementação Runnable permite-lhe ter esta flexibilidade para compartilhar o objeto enquanto extends Thread faz você para criar novos objetos para cada tópicos, portanto, qualquer atualização que é feito por thread1 está perdido para thread2.

A separação da classe Thread da implementação Runnable também evita problemas de sincronização de potencial entre o método run () fio e. Uma Runnable separado geralmente dá maior flexibilidade na maneira que o código executável é referenciado e executado.

Essa é a S de SOLID: responsabilidade Individual.

A fio encarna o contexto em execução (como no contexto de execução: quadro de pilha, id fio, etc.) do execução assíncrona de um pedaço de código. Que pedaço de código , idealmente, deve ser a mesma aplicação, se síncrona ou assíncrona .

Se você empacotá-los juntos em uma aplicação, você dá o objeto resultante dois não relacionados causas da mudança:

manipulação fio em sua aplicação (ie. Consultar e modificar o contexto de execução)
algoritmo implementado pelo pedaço de código (a parte executável)

Se a linguagem que você usa suportes classes parciais ou herança múltipla, então você pode segregar cada causa em sua própria classe super, mas resume-se ao mesmo como compor os dois objetos, uma vez que seus conjuntos de recursos não se sobrepõem. Isso é para a teoria.

Na prática, em geral, um programa não precisa de transportar mais complexidade do que o necessário. Se você tiver um fio trabalhando em uma tarefa específica, sem nunca mudar essa tarefa, provavelmente há nenhum ponto em fazer as tarefas classes separadas, e seu código continua a ser mais simples.

No contexto da Java , uma vez que a instalação é já existe , é provavelmente mais fácil começar diretamente com pé aulas Runnable sozinho, e passar as suas instâncias para Thread ( ou Executor) casos. Uma vez que usado a esse padrão, não mais difícil é para uso (ou até mesmo ler) do que o caso segmento executável simples.

Uma das razões que você gostaria de implementar uma interface em vez de estender uma classe base é que você já estão estendendo alguma outra classe. Você só pode estender uma classe, mas você pode implementar qualquer número de interfaces.

Se você estender Thread, você está impedindo que basicamente sua lógica para ser executado por qualquer outro segmento do que 'isto'. Se você só deseja alguns thread para executar a sua lógica, é melhor apenas para implementar Runnable.

Se você usar executável você pode salvar o espaço para estender a alguma de sua outra classe.

Podemos re-visitar a razão básica que queríamos a nossa classe se comportar como um Thread? Não há nenhuma razão em tudo, nós só queríamos para executar uma tarefa, provavelmente em um modo assíncrono, o que exatamente significa que a execução do ramo must tarefa do nosso segmento principal e o segmento principal se acabamentos cedo, pode ou não pode esperar para o caminho ramificada (tarefa).

Se este é o propósito, então onde é que eu vejo a necessidade de um segmento especializado. Isso pode ser feito por pegar um segmento RAW a partir da linha do Pool System e atribuindo-lhe a nossa tarefa (pode ser uma instância de nossa classe) e que é ele.

Por isso, vamos obedecer o conceito OOPs e escrever uma classe do tipo que precisamos. Há muitas maneiras de fazer as coisas, fazendo-o nos assuntos caminho certo.

Precisamos de uma tarefa, para escrever uma definição de tarefa que pode ser executado em um Thread. Portanto, use Runnable.

Lembre-se sempre implements é usado especialmente para conferir um comportamento e extends é usado para transmitir uma característica / propriedade.

Não queremos que a propriedade do fio, em vez queremos que a nossa classe se comportar como uma tarefa que pode ser executado.

Sim, Se você chamar chamada ThreadA, então não precisa chamar o método de início e método de execução é chamada após a chamada somente a classe ThreadA. Mas se usar a chamada ThreadB precisa então necessário o segmento de início para chamada de método run. Se você tem mais alguma ajuda, me responda.

Eu acho que é mais útil para usar Runnable por todas as razões mencionadas, mas às vezes eu gostaria de estender Tópico para que eu possa criar o meu próprio método de parar fio e chamá-lo diretamente no thread eu criei.

Java não suporta múltiplos inheritence isso, se você estende classe Thread, em seguida, nenhuma outra classe será estendido.

Por exemplo: Se você criar um applet, então ele deve estende a classe Applet então aqui a única maneira de criar linha é através da implementação de interface Runnable

Runnable é uma interface, enquanto Thread é uma classe que implementa essa interface. Do ponto de vista do design, deve haver uma separação clara entre a forma como uma tarefa é definido e entre a forma como ele é executado. O primeiro é a responsabilidade de uma implementação Runnalbe, eo segundo é o trabalho da classe Thread. Na maioria dos casos de aplicação Runnable é o caminho certo a seguir.

Diferença entre rosca e executável .Se estamos criando segmento usando classe Thread seguida Número de rosca igual a número de objeto que criamos. Se estamos criando fio implementando a interface executável então podemos usar único objeto para a criação de múltiplos thread.So único objeto é compartilhado por vários Thread.So vai demorar menos memória

Assim, dependendo da exigência, se os nossos dados não é senstive. Assim, ele pode ser compartilhado entre vários segmentos podemos usadas interface Runnable.

Como adicionar meus dois centavos aqui - Sempre, sempre que possível utilização implements Runnable. Abaixo estão duas ressalvas sobre por que você não deve usar extends Threads

O ideal é que você nunca deve estender a classe Thread; a classe Thread deve ser feita final. Pelo menos seus métodos como thread.getId(). Consulte esta discussão para um erro relacionado com Threads se estendem.
Aqueles que gostam de resolver quebra-cabeças pode ver um outro efeito colateral de estender Thread. O código abaixo imprimirá código inacessível quando ninguém está notificando-os.

Por favor, veja http://pastebin.com/BjKNNs2G .

public class WaitPuzzle {

    public static void main(String[] args) throws InterruptedException {
        DoNothing doNothing = new DoNothing();
        new WaitForever(doNothing).start();
        new WaitForever(doNothing).start();
        new WaitForever(doNothing).start();
        Thread.sleep(100);
        doNothing.start();
        while(true) {
            Thread.sleep(10);
        }
    }


    static class WaitForever extends  Thread {

        private DoNothing doNothing;

        public WaitForever(DoNothing doNothing) {
            this.doNothing =  doNothing;
        }

        @Override
        public void run() {
            synchronized (doNothing) {
                try {
                    doNothing.wait(); // will wait forever here as nobody notifies here
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Unreachable Code");
            }
        }
    }

    static class DoNothing extends Thread {

        @Override
        public void run() {
            System.out.println("Do Nothing ");
        }
    } 
}

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow