Interface executável em Java: implementação, etapas e erros

Publicados: 2021-05-02

Índice

Introdução

Uma interface executável em Java é uma interface cujas instâncias podem ser executadas como um Thread. Ao trabalhar com Threads, a interface executável atua como um elemento central da linguagem de programação Java. As classes Java criadas para executar Threads devem implementar essa interface. Este artigo fornecerá uma compreensão profunda da interface executável em Java e do processo de implementação.

O que é a interface executável em Java?

Uma interface executável é uma interface que contém um único método. O programa Java define esse único método no pacote java.lang e o chama na execução da classe de encadeamento. Ele fornece um modelo para objetos que uma classe pode implementar usando Threads. Você pode implementar a interface executável em Java de uma das seguintes maneiras:

  • Usando thread de subclasse
  • Substituindo o método run()

Java não permite heranças múltiplas no programa. Você pode estender apenas uma classe e, ao estender uma classe de thread, ela consome mais memória, tempo de computação e outros recursos. Portanto, ele adiciona a sobrecarga de usar métodos adicionais. Das duas opções acima, é melhor usar uma interface executável para criar um thread. Para fazer isso, você deve fornecer a implementação para o método run().

Etapas para criar um thread usando a interface executável em Java

Execute as etapas a seguir para criar um encadeamento usando a interface executável em Java .

  1. Crie uma classe de thread que implementará a interface executável.
  2. Na classe thread, escreva uma função para substituir o método run().
  3. Crie uma instância da classe Thread.
  4. A instância do thread tem um construtor que aceita o objeto executável. Passe este objeto como parâmetro para a instância do thread.
  5. Por fim, chame o método start da instância do thread.

Leia também: Ideias e tópicos do projeto Java

Implementação da interface executável em Java

A implementação do método run() é a maneira mais fácil de criar um novo thread. Ele atua como um ponto de partida para a criação de um novo Thread. A implementação da interface executável usa o código dentro do método run() e o executa em um thread simultâneo. Você pode invocar a classe, criar novas variáveis ​​ou chamar a ação no método run() para implementar a interface executável em Java . O programa garante que o encadeamento esteja inativo até que ele imprima a instrução de retorno no código.

public class TestRunnableInterface {

public static void main(String[] args) {

System.out.println(“Do método primário(): ” + Thread.currentThread().getName());

System.out.println(“Implementando a interface executável em Java ”);

Instância executável = new Runnable() {@Override

public void executar() {

System.out.println(“Do método run(): ” + Thread.currentThread().getName());

}

};

System.out.println(“Crie uma nova instância do objeto thread.”);

Teste de thread = new Thread(instância);

System.out.println(“Executando a thread!”);

teste.início();

}

}

Saída

Do método primary(): main

Implementando a interface executável em Java

Crie uma nova instância do objeto thread.

Do método run(): Thread-0

Erros encontrados ao implementar a interface executável em Java

O método run() gera um erro de exceção de tempo de execução quando o programa é interrompido devido a um erro de sintaxe ou de código. Se uma máquina virtual Java não detectar os erros, o encadeamento criado tratará a exceção perdida pela JVM. O manipulador de exceção imprime a exceção e interrompe o programa.

import java.io.FileNotFoundException;

public class TestRunnableInterface {

public static void main(String[] args) {

System.out.println(“A thread primária é: ” + Thread.currentThread().getName());

Teste de thread = new Thread(new TestRunnableInterface().new DemoInstance());

teste.início();

}

classe privada DemoInstance implementa Runnable {

public void executar() {

System.out.println(Thread.currentThread().getName() + “, invocando o método run()!”);

experimentar {

lançar novo FileNotFoundException();

}

catch(FileNotFoundException demo) {

System.out.println(“Pegou um erro!”);

demo.printStackTrace();

}

}

}

}

Saída

O thread principal é: main

Thread-0, invocando o método run()!

Pegou um erro!

java.io.FileNotFoundException

em TestRunnableInterface$DemoInstance.run(Example.java:21)

em java.lang.Thread.run(Thread.java:748)

A classe TestRunnableInterface no programa acima não lança a exceção FileNotFoundException. A máquina virtual Java cuida das exceções que deveriam ter sido tratadas pela classe TestRunnableInstance.

Caso de uso da interface executável em Java

A interface executável em Java é usada em um cenário de rede em que o servidor recebe várias solicitações de conexão de clientes. A interface executável em Java lida com isso de forma rápida e eficiente executando programação multi-thread.

Aprenda cursos de desenvolvimento de software online das melhores universidades do mundo. Ganhe Programas PG Executivos, Programas de Certificado Avançado ou Programas de Mestrado para acelerar sua carreira.

Conclusão

Em poucas palavras, uma interface executável em Java é sempre uma escolha melhor em comparação com o thread de subclasse quando se trata de criar threads em Java. O código usado no artigo é apenas para fins explicativos. Você pode modificar as declarações fornecidas nos exemplos conforme suas necessidades. Neste artigo, aprendemos sobre a interface executável em Java e como você pode criar um thread implementando a interface executável em Java .

Você pode experimentar o código para fortalecer o conhecimento do construtor Java . Se você deseja obter uma compreensão profunda de Java, confira o curso upGrad Executive PG Program in Full Stack Development . Este curso é projetado para profissionais que trabalham e oferece treinamento rigoroso e assistência no trabalho com as principais empresas.

O que é multithreading em Java?

Multithreading é um conceito em Java no qual as tarefas são executadas simultaneamente. Ele permite que um programa execute muitas tarefas diferentes simultaneamente, em vez de esperar que uma única tarefa seja concluída. É um dos tópicos mais populares dos desenvolvedores Java e Java. Multithreading é um dos recursos mais poderosos do java. Ele usa a CPU efetivamente executando vários threads. Java tem uma construção especial chamada thread. Uma thread é basicamente um processo de software que pode executar uma sequência arbitrária de instruções de bytecode Java. A execução de cada thread é independente de outras threads. Os desenvolvedores podem criar um novo encadeamento a qualquer momento e a JVM tratará da execução desse encadeamento. Isso ajuda no desenvolvimento de aplicativos altamente escaláveis ​​e responsivos.

O que é interface executável em Java?

A interface executável é usada para escrever aplicativos que podem ser executados em um thread separado. Qualquer classe que implementa a interface executável é chamada de thread. O código do encadeamento é executado pelo interpretador após o início do encadeamento. Você pode implementar a interface executável e criar seu próprio programa multithreading. Existem duas maneiras de implementar essa interface. A primeira é usando a subclasse thread. A outra é sobrescrevendo o método run().

Como o multithreading realmente funciona?