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.
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:
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.
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:
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:
No exemplo acima, realizamos o Multithreading implementando a interface executável. Para saber mais sobre multithreading, Clique aqui .