logo

Conceito de thread em Java

Antes de apresentar o conceito de thread , não conseguimos executar mais de uma tarefa em paralelo. Era uma desvantagem, e para eliminar essa desvantagem, Conceito de thread foi introduzido.

A Fio é um processo muito leve, ou podemos dizer a menor parte do processo que permite que um programa opere com mais eficiência executando várias tarefas simultaneamente.

comparar com java

Para realizar tarefas complicadas em segundo plano, usamos o Conceito de thread em Java . Todas as tarefas são executadas sem afetar o programa principal. Em um programa ou processo, todos os threads possuem seu próprio caminho separado para execução, portanto, cada thread de um processo é independente.

Conceito de thread em Java

Outro benefício de usar fio é que se um thread obtiver uma exceção ou erro no momento de sua execução, isso não afetará a execução dos outros threads. Todas as threads compartilham uma memória comum e possuem sua própria pilha, variáveis ​​locais e contador de programa. Quando vários threads são executados em paralelo ao mesmo tempo, esse processo é conhecido como Multithreading .

De forma simples, um Thread é um:

  • Recurso através do qual podemos realizar múltiplas atividades dentro de um único processo.
  • Processo leve.
  • Série de instruções executadas.
  • Sequência aninhada de chamadas de método.

Modelo de rosca

Assim como um processo, um thread existe em vários estados. Esses estados são os seguintes:

Conceito de thread em Java

1) Novo (pronto para funcionar)

Um tópico está em Novo quando chega o tempo da CPU.

2) Correndo

Um tópico está em uma corrida informar quando estiver em execução.

3) Suspenso

Um tópico está no Suspenso estado quando estiver temporariamente inativo ou em execução.

funcionamento interno do hashmap

4) Bloqueado

Um tópico está no Bloqueado estado quando está aguardando recursos.

5) Rescindido

Um thread chega nesse estado quando, a qualquer momento, interrompe sua execução imediatamente.

Criando Tópico

Um thread é criado 'criando ou implementando' o Interface executável ou estendendo o Classe de thread . Estas são as únicas duas maneiras pelas quais podemos criar um thread.

Vamos mergulhar nos detalhes dessas duas formas de criar um tópico:

Classe de thread

A Classe de thread possui vários métodos e construtores que nos permitem realizar diversas operações em um thread. A classe Thread estende o Objeto aula. O Objeto classe implementa o Executável interface. A classe thread possui os seguintes construtores que são usados ​​para executar várias operações.

    Fio() Thread (Executável, nome da string) Thread (alvo executável) Thread (grupo ThreadGroup, destino executável, nome da string) Thread (grupo ThreadGroup, destino executável) Thread (grupo ThreadGroup, nome da string) Thread (grupo ThreadGroup, destino executável, nome da string, stackSize longo)

Interface executável (método run())

A interface Runnable deve ser implementada pela classe cujas instâncias devem ser executadas por um thread. A interface executável nos dá a correr() método para executar uma ação para o thread.

quão grande é o meu monitor

método start()

O método é usado para iniciar um thread que criamos recentemente. Ele inicia um novo thread com uma nova pilha de chamadas. Depois de executar o começar() método, o thread altera o estado de Novo para Executável. Ele executa o método executar() quando o thread obtém o momento correto para executá-lo.

Vamos dar um exemplo para entender como podemos criar um Java thread estendendo a classe Thread:

ThreadExample1.java

 // Implementing runnable interface by extending Thread class public class ThreadExample1 extends Thread { // run() method to perform action for thread. public void run() { int a= 10; int b=12; int result = a+b; System.out.println('Thread started running..'); System.out.println('Sum of two numbers is: '+ result); } public static void main( String args[] ) { // Creating instance of the class extend Thread class ThreadExample1 t1 = new ThreadExample1(); //calling start method to execute the run() method of the Thread class t1.start(); } } 

Saída:

Conceito de thread em Java

Criando thread implementando a interface executável

Em Java, também podemos criar um thread implementando a interface executável. A interface executável nos fornece o método run() e o método start().

Vamos dar um exemplo para entender como podemos criar, iniciar e executar o thread usando a interface executável.

ThreadExample2.java

 class NewThread implements Runnable { String name; Thread thread; NewThread (String name){ this.name = name; thread = new Thread(this, name); System.out.println( 'A New thread: ' + thread+ 'is created
' ); thread.start(); } public void run() { try { for(int j = 5; j > 0; j--) { System.out.println(name + ': ' + j); Thread.sleep(1000); } }catch (InterruptedException e) { System.out.println(name + ' thread Interrupted'); } System.out.println(name + ' thread exiting.'); } } class ThreadExample2 { public static void main(String args[]) { new NewThread('1st'); new NewThread('2nd'); new NewThread('3rd'); try { Thread.sleep(8000); } catch (InterruptedException excetion) { System.out.println('Inturruption occurs in Main Thread'); } System.out.println('We are exiting from Main Thread'); } } 

Saída:

Conceito de thread em Java

No exemplo acima, realizamos o Multithreading implementando a interface executável. Para saber mais sobre multithreading, Clique aqui .