Multithreading em Java

Qualquer aplicativo pode ter vários processos (instâncias). Cada um desses processos pode ser atribuído como um único thread ou como vários threads. Veremos neste tutorial como realizar múltiplas tarefas ao mesmo tempo e também aprenderemos mais sobre threads e sincronização entre threads.

O que é thread único?

Um único tópico em Java é basicamente uma unidade de processamento leve e menor. Java usa threads usando uma “Thread Class”. Existem dois tipos de thread – thread de usuário e thread daemon (os threads daemon são usados ​​quando queremos limpar o aplicativo e são usados ​​em segundo plano). Quando um aplicativo é iniciado pela primeira vez, o thread do usuário é criado. Depois disso, podemos criar muitos threads do usuário e threads daemon.

Exemplo de thread único:

package demotest;

public class GuruThread
{
       public static void main(String[] args) {
              System.out.println("Single Thread");
       }
}

Vantagens do thread único:

• Reduz a sobrecarga no aplicativo à medida que um único thread é executado no sistema
• Além disso, reduz o custo de manutenção do aplicativo.

Exemplo de multithread:

package demotest;
public class GuruThread1 implements Runnable
{
       public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Vantagens do multithread:

• Os usuários não são bloqueados porque os threads são independentes e às vezes podemos realizar várias operações
• Como tal, os threads são independentes, os outros threads não serão afetados se um thread atender a uma exceção.

Ciclo de vida do thread em Java

O ciclo de vida de um thread:

Existem vários estágios do ciclo de vida do thread, conforme mostrado no diagrama acima:

1. New
2. Executável
3. Corrida
4. Esperando
5. Dead

1. Novo: Nesta fase, o thread é criado utilizando a classe “Thread class”. Ele permanece neste estado até o programa começa o segmento. Também é conhecido como fio nascido.
2. Executável: Nesta página, a instância do thread é invocada com um método start. O controle do thread é dado ao agendador para finalizar a execução. Depende do agendador se o thread deve ser executado.
3. Corrida: Quando o thread começa a ser executado, o estado é alterado para o estado “em execução”. O agendador seleciona um thread do pool de threads e começa a ser executado no aplicativo.
4. Esperando: Este é o estado em que um thread deve esperar. Como há vários threads em execução no aplicativo, há necessidade de sincronização entre os threads. Portanto, um thread tem que esperar até que o outro thread seja executado. Portanto, este estado é referido como estado de espera.
5. Morto: Este é o estado quando o thread é encerrado. O thread está em estado de execução e assim que conclui o processamento ele está em “estado morto”.

Métodos de Multithreading em Java

Alguns dos métodos comumente usados ​​para threads são:

Forma	Descrição
começar()	Este método inicia a execução do thread e JVM chama o método run() no thread.
Dormir (int milissegundos)	Este método faz o thread dormir, portanto a execução do thread será pausada por milissegundos fornecidos e depois disso, o thread começará a ser executado novamente. Isso ajuda na sincronização dos threads.
getName ()	Ele retorna o nome do thread.
setPriority(int novaprioridade)	Isso altera a prioridade do thread.
colheita ()	Isso faz com que o thread atual seja interrompido e outros threads sejam executados.

Exemplo: Neste programa multithreading em Java Por exemplo, vamos criar um thread e explorar métodos integrados disponíveis para threads.

package demotest;
public class thread_example1 implements Runnable {
    @Override
    public void run() {
    }
    public static void main(String[] args) {
        Thread guruthread1 = new Thread();
        guruthread1.start();
        try {
            guruthread1.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        guruthread1.setPriority(1);
        int gurupriority = guruthread1.getPriority();
        System.out.println(gurupriority);
        System.out.println("Thread Running");
  }
}

Explicação do código:

• Code Linha 2: Estamos criando uma classe “thread_Example1” que implementa a interface Runnable (ela deve ser implementada por qualquer classe cujas instâncias sejam executadas pelo thread).
• Code Linha 4: Ele substitui o método run da interface executável, pois é obrigatório substituir esse método
• Code Linha 6: Aqui definimos o método principal no qual iniciaremos a execução do thread.
• Code Linha 7: Aqui estamos criando um novo nome de thread como “guruthread1” instanciando uma nova classe de thread.
• Code Linha 8: usaremos o método “start” do thread usando a instância “guruthread1”. Aqui o thread começará a ser executado.
• Code Linha 10: Aqui estamos usando o método “sleep” do thread usando a instância “guruthread1”. Conseqüentemente, o thread ficará suspenso por 1000 milissegundos.
• Code 9-14: Aqui colocamos o método sleep no bloco try catch, pois há uma exceção verificada que ocorre, ou seja, exceção interrompida.
• Code Linha 15: Aqui estamos definindo a prioridade do thread para 1 de qualquer prioridade que fosse
• Code Linha 16: Aqui estamos obtendo a prioridade do thread usando getPriority()
• Code Linha 17: Aqui estamos imprimindo o valor obtido em getPriority
• Code Linha 18: Aqui estamos escrevendo um texto que o tópico está rodando.

Ao executar o código acima, você obtém a seguinte saída:

Saída:

5 é a prioridade do Thread e Thread Running é o texto que é a saída do nosso código.

Java Fio Synchronização

Em multithreading, há o comportamento assíncrono dos programas. Se um thread estiver gravando alguns dados e outro thread estiver lendo dados ao mesmo tempo, pode criar inconsistência no aplicativo. Quando há necessidade de acessar os recursos compartilhados por dois ou mais threads, então a abordagem de sincronização é utilizada. Java forneceu métodos sincronizados para implementar comportamento sincronizado.

Nessa abordagem, uma vez que o thread alcança o bloco synchronized, então nenhum outro thread pode chamar esse método no mesmo objeto. Todos os threads têm que esperar até que o thread termine o bloco synchronized e saia dele. Dessa forma, a sincronização ajuda em um aplicativo multithread. Um thread tem que esperar até que outro thread termine sua execução, somente então os outros threads são permitidos para execução.

Pode ser escrito da seguinte forma:

Synchronized(object)
{  
        //Block of statements to be synchronized
}

Multithreading em Java Programas de exemplo

Neste multithreading Java Por exemplo, pegaremos dois threads e buscaremos os nomes dos threads.

Exemplo1:

GuruThread1.java
package demotest;
public class GuruThread1 implements Runnable{

    /**
     * @param args
     */
    public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Explicação do código:

• Code Linha 3: Fizemos um curso “GuruThread1”, que implementa Runnable (deve ser implementada por qualquer classe cujas instâncias se destinam a ser executadas pela thread).
• Code Linha 8: Este é o método principal da classe
• Code Linha 9: Aqui estamos instanciando a classe Thread e criando uma instância chamada “guruThread1” e criando um thread.
• Code Linha 10: Aqui estamos instanciando a classe Thread e criando uma instância chamada “guruThread2” e criando um thread.
• Code Linha 11: Estamos iniciando o tópico, ou seja, guruThread1.
• Code Linha 12: Estamos iniciando o tópico, ou seja, guruThread2.
• Code Linha 13: Produzindo o texto como “Os nomes dos threads são os seguintes:”
• Code Linha 14: Obtendo o nome do thread 1 usando o método getName() da classe thread.
• Code Linha 15: Obtendo o nome do thread 2 usando o método getName() da classe thread.

Ao executar o código acima, você obtém a seguinte saída:

Saída:

Os nomes dos threads estão sendo exibidos aqui como

• Guru1
• Guru2

2 exemplo:

Neste multithreading em Java Por exemplo, aprenderemos sobre como substituir os métodos run() e start() de uma interface executável e criar dois threads dessa classe e executá-los de acordo.

Além disso, estamos tendo duas aulas,

• Um que implementará a interface executável e
• Outro que terá o método principal e será executado de acordo.

package demotest;
public class GuruThread2 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  GuruThread3 threadguru1 = new GuruThread3("guru1");
  threadguru1.start();
  GuruThread3 threadguru2 = new GuruThread3("guru2");
  threadguru2.start();
 }
}
class GuruThread3 implements Runnable {
 Thread guruthread;
 private String guruname;
 GuruThread3(String name) {
  guruname = name;
 }
 @Override
 public void run() {
  System.out.println("Thread running" + guruname);
  for (int i = 0; i < 4; i++) {
   System.out.println(i);
   System.out.println(guruname);
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    System.out.println("Thread has been interrupted");
   }
  }
 }
 public void start() {
  System.out.println("Thread started");
  if (guruthread == null) {
   guruthread = new Thread(this, guruname);
   guruthread.start();
  }
 }
}

Explicação do código:

• Code Linha 2: Aqui estamos tendo uma aula “GuruThread2”, que conterá o método principal.
• Code Linha 4: Aqui estamos pegando um método principal da classe.
• Code Linha 6-7: Aqui estamos criando uma instância da classe. GuruA Thread3 (criada nas linhas de código abaixo) é denominada “threadguru1” e estamos iniciando a thread.
• Code Linha 8-9: Aqui estamos criando outra instância da classe. GuruA Thread3 (criada nas linhas de código abaixo) é denominada “threadguru2” e estamos iniciando a thread.
• Code Linha 11: Aqui estamos criando uma classe “GuruThread3”, que implementa a interface Runnable (ela deve ser implementada por qualquer classe cujas instâncias se destinam a ser executadas pela thread).
• Code Linha 13-14: estamos pegando duas variáveis ​​de classe, das quais uma é do tipo classe thread e outra da classe string.
• Code Linha 15-18: estamos anulando o GuruO construtor Thread3 recebe um argumento do tipo string (que é o nome da thread) e o atribui à variável de classe guruname, armazenando assim o nome da thread.
• Code Linha 20: Aqui estamos substituindo o método run() da interface executável.
• Code Linha 21: Estamos gerando o nome do thread usando a instrução println.
• Code Linha 22-31: Aqui estamos usando um loop for com contador inicializado em 0, e não deve ser menor que 4 (podemos pegar qualquer número, portanto aqui o loop será executado 4 vezes) e incrementando o contador. Estamos imprimindo o nome do thread e também fazendo com que o thread fique suspenso por 1000 milissegundos dentro de um bloco try-catch, pois o método sleep gerou uma exceção verificada.
• Code Linha 33: Aqui estamos substituindo o método start da interface executável.
• Code Linha 35: Estamos exibindo o texto “Tópico iniciado”.
• Code Linha 36-40: Aqui estamos adotando uma condição if para verificar se a variável de classe guruthread tem valor ou não. Se for nulo, então estamos criando uma instância usando a classe thread que leva o nome como parâmetro (valor para o qual foi atribuído no construtor). Depois disso, o thread é iniciado usando o método start().

Ao executar o código acima você obtém a seguinte saída:

saída:

Existem dois threads, portanto, recebemos duas vezes a mensagem “Tópico iniciado”.

Obtemos os nomes dos threads conforme os geramos.

Ele entra no loop for onde imprimimos o contador e o nome do thread e o contador começa com 0.

O loop é executado três vezes e entre o thread fica inativo por 1000 milissegundos.

Portanto, primeiro obtemos guru1, depois guru2 e novamente guru2 porque o thread dorme aqui por 1000 milissegundos e depois o próximo guru1 e novamente guru1, o thread dorme por 1000 milissegundos, então obtemos guru2 e depois guru1.

Resumo

Neste tutorial, vimos aplicativos multithread em Java e como usar thread único e multi thread em Java.

• Explique multithreading em Java: no multithreading, os usuários não são bloqueados, pois os threads são independentes e podem executar várias operações ao mesmo tempo
• Vários estágios do ciclo de vida do fio são,
  • New
  • Executável
  • Corrida
  • Esperando
  • Dead
• Também aprendemos sobre Sincronização entre threads, o que ajuda o aplicativo a funcionar sem problemas.
• Programação multithread em Java facilita muito mais tarefas de aplicação.