Contente

• Gráfico de comparação
• Definição de Classe de Thread
• Definição da interface executável
• Principais diferenças entre thread e executável em Java
• Conclusão:

Um encadeamento pode ser definido de duas maneiras. Primeiro, por estendendo uma classe Thread que já implementou uma interface Runnable. Segundo, diretamente implementando uma interface Runnable. Ao definir um encadeamento estendendo a classe Thread, você deve substituir o método run () na classe Thread. Ao definir um encadeamento implementando uma interface Runnable, você deve implementar o único método run () da interface Runnable. A diferença básica entre Thread e Runnable é que cada thread definido pela extensão da classe Thread cria um objeto exclusivo e é associado a esse objeto. Por outro lado, cada thread definido pela implementação da interface Runnable compartilha o mesmo objeto.

Vamos observar algumas outras diferenças entre Thread e Runnable com a ajuda do gráfico de comparação mostrado abaixo:

1. Gráfico de comparação
2. Definição
3. Principais diferenças
4. Conclusão

Gráfico de comparação

Base para Comparação	Fio	Executável
Basic	Cada thread cria um objeto exclusivo e é associado a ele.	Vários segmentos compartilham os mesmos objetos.
Memória	À medida que cada thread cria um objeto exclusivo, é necessária mais memória.	Como vários threads compartilham o mesmo objeto, menos memória é usada.
Estendendo	Em Java, herança múltipla não é permitida, portanto, depois que uma classe estende a classe Thread, ela não pode estender nenhuma outra classe.	Se uma classe definir um encadeamento implementando a interface Runnable, ela poderá estender uma classe.
Usar	Um usuário deve estender a classe de encadeamento apenas se desejar substituir os outros métodos na classe Encadeamento.	Se você deseja apenas se especializar no método de execução, a implementação do Runnable é uma opção melhor.
Acoplamento	A classe Estendendo Thread introduz um acoplamento rígido, pois a classe contém o código da classe Thread e também o trabalho atribuído à thread	A implementação da interface Runnable introduz um acoplamento flexível, pois o código do Thread é separado do trabalho dos Threads.

Definição de Classe de Thread

Fio é uma classe em java.lang pacote. A classe Thread estende um Objeto classe e implementa Executável interfaces. A classe Thread possui construtores e métodos para criar e operar no thread. Quando criamos vários threads, cada thread cria um objeto exclusivo e é associado a esse objeto. Se você criar um segmento estendendo a classe Thread, além disso, não poderá estender nenhuma outra classe, pois o java não suporta herança múltipla. Portanto, você deve optar por estender a classe Thread apenas quando quiser substituir outros métodos da classe Thread. Vamos ver um exemplo de criação de um thread estendendo uma classe Thread.

/ * Definindo um thread * / Class Mythread estende o Thread {/ * trabalho do thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Thread filho" ); }} Classe mainThread {/ * trabalho do thread principal * / public static void main (String args) {Mythread mt = new Mythread (); / * thread principal criou o thread filho * / mt.start (); for (int i = 0; i <10; i ++) {System.Out. ("Tópico Principal"); }}} / * Saída * / Linha principal Linha principal Linha principal Linha principal Linha infantil Linha infantil Linha infantil Linha infantil Linha infantil Linha principal Linha infantil Linha principal Linha principal Linha principal Linha infantil Linha infantil Linha infantil Linha principal Linha principal Linha infantil Linha infantil Linha principal

No código acima, eu crio uma classe Mythread que estende a classe Thread e substitui um método run da classe Thread. Na classe que contém o método principal, crio um objeto de thread (mt) da classe Mythread e, usando o objeto de thread, invoquei o método start (). O método start inicia a execução do encadeamento e, ao mesmo tempo, a JVM chama o método run do encadeamento. Agora, existem dois encadeamentos no programa, um encadeamento principal e um segundo encadeamento filho, criados pelo encadeamento principal. A execução de ambos os encadeamentos ocorre simultaneamente, mas a saída exata não pode ser pretendida.

Definição da interface executável

Executável é uma interface em java.lang pacote. Implementando a interface Runnable, podemos definir um encadeamento. A interface executável possui um único método corre(), que é implementado pela classe que implementa a interface Runnable. Quando você escolhe definir o encadeamento implementando uma interface Runnable, ainda tem a opção de estender qualquer outra classe. Quando você cria vários threads implementando a interface Runnable, cada thread compartilha a mesma instância executável. vamos aprender como definir um thread usando a interface Runnable.

/ * Definindo um thread * / Class Runnablethread implementa Runnable {/ * trabalho do thread * / public void run () {for (int i = 0; i <10; i ++) {System.Out.ln ("Thread filho" ); }} Classe mainThread {/ * trabalho do thread principal * / public static void main (String args) {Mythread rt = new Mythread (); / * thread principal criou o objeto executável * / Thread t = new Thread (rt); / * thread principal cria thread filho e passou o objeto executável * / t.start (); for (int i = 0; i <10; i ++) {System.Out. ("Tópico Principal"); }}} / * Saída * / Linha principal Linha principal Linha principal Linha principal Linha infantil Linha infantil Linha infantil Linha infantil Linha infantil Linha principal Linha infantil Linha principal Linha principal Linha principal Linha infantil Linha infantil Linha infantil Linha principal Linha principal Linha infantil Linha infantil Linha principal

No código acima, criei uma classe Runnablethread que implementa a interface Runnable e define o trabalho do thread implementando o método run () da interface Runnable. Então eu crio uma classe mainthread contendo o método main. Dentro do método principal, declarei um objeto executável da classe Runnablethread e passei esse objeto para o construtor do Thread enquanto declarava um thread. Dessa maneira, vinculei o objeto de thread (t) a um objeto executável (rt). Em seguida, o objeto de thread chama o método start do thread, que chama ainda mais o método run da classe Runnablethread. Se eu não tivesse vinculado um objeto executável ao objeto Thread, o método de início de threads teria invocado o método run da classe Thread. Agora, novamente, existem dois threads no código, o thread principal e o thread principal, que criam um thread filho, ambos são executados simultaneamente, mas a saída exata nunca pode ser pretendida.

Principais diferenças entre thread e executável em Java

1. Cada encadeamento criado pela extensão da classe Thread cria um objeto exclusivo para ele e é associado a esse objeto. Por outro lado, cada encadeamento criado pela implementação de uma interface Runnable compartilha a mesma instância executável.
2. Como cada thread é associado a um objeto exclusivo quando criado pela extensão da classe Thread, é necessária mais memória. Por outro lado, cada encadeamento criado pela implementação da interface Runnable compartilha o mesmo espaço de objeto, portanto, requer menos memória.
3. Se você estender a classe Thread ainda mais, poderá herdar qualquer outra classe, pois o Java não permitirá herança múltipla, ao implementar o Runnable, ainda haverá uma chance de uma classe herdar qualquer outra classe.
4. É necessário estender uma classe Thread apenas se ela tiver que substituir ou especializar alguns outros métodos da classe Thread. Você deve implementar uma interface Runnable se desejar apenas se especializar apenas no método de execução.
5. Estender a classe Thread introduz um acoplamento rígido no código, pois o código de Thread e o trabalho de thread são contidos pela mesma classe. Por outro lado, a interface Implementing Runnable introduz um acoplamento flexível no código, à medida que o código do Thread é separado do trabalho atribuído ao thread.

Conclusão:

É preferível implementar uma interface Runnable em vez de estender a classe Thread. A implementação do Runnable torna seu código fracamente acoplado, pois o código do thread é diferente da classe que atribui o trabalho ao thread. Requer menos memória e também permite que uma classe herde qualquer outra classe.