Tutorial de multithreading em Java com programa e exemplos

Ciclo de vida da thread em Java

1. Novo
2. Executável
3. Correndo
4. Aguardando
5. Morto

1. Novo: Nesta fase, o thread é criado usando a classe “Thread class”. Permanece neste estado até o programa iniciar o segmento. Também é conhecido como thread nascido.
2. Executável: Nesta página, a instância do thread é invocada com um método start. O controle de thread é dado ao escalonador para finalizar a execução. Depende do agendador, se deve executar o encadeamento.
3. Em execução: Quando o encadeamento começa a ser executado, o estado é alterado para o estado “executando”. O agendador seleciona um encadeamento do pool de encadeamentos e começa a ser executado no aplicativo.
4. Aguardando: Este é o estado em que um thread tem que esperar. Como existem vários threads em execução no aplicativo, há a necessidade de sincronização entre os threads. Assim, um thread tem que esperar, até que o outro thread seja executado. Portanto, esse estado é referido como estado de espera.
5. Morto: Este é o estado quando o encadeamento é encerrado. O encadeamento está em estado de execução e, assim que concluir o processamento, estará em "estado morto".

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");
  }
}

• Linha de código 2: Estamos criando uma classe “thread_Example1” que está implementando a interface Runnable (ela deve ser implementada por qualquer classe cujas instâncias devem ser executadas pela thread.)
• Linha de código 4: Ele substitui o método run da interface executável, pois é obrigatório substituir esse método
• Linha de código 6: Aqui definimos o método principal no qual iniciaremos a execução da thread.
• Linha de código 7: Aqui estamos criando um novo nome de thread como “guruthread1” instanciando uma nova classe de thread.
• Linha de código 8: usaremos o método “start” da thread usando a instância “guruthread1”. Aqui o encadeamento começará a ser executado.
• Linha de código 10: Aqui estamos usando o método “sleep” do thread usando a instância “guruthread1”. Portanto, o encadeamento ficará inativo por 1.000 milissegundos.
• Código 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.
• Linha de código 15: Aqui estamos definindo a prioridade do encadeamento para 1 de qualquer prioridade que tenha sido
• Linha de código 16: Aqui estamos obtendo a prioridade do thread usando getPriority()
• Linha de código 17: Aqui estamos imprimindo o valor obtido de getPriority
• Linha de código 18: Aqui estamos escrevendo um texto que o thread está executando.

Saída:

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

Sincronização de thread Java

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

Exemplo de multithread Java

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() {
    }
}

• Linha de código 3: Pegamos uma classe “GuruThread1” que implementa Runnable (deve ser implementada por qualquer classe cujas instâncias devem ser executadas pelo thread.)
• Linha de código 8: Este é o método principal da classe
• Linha de código 9: Aqui estamos instanciando a classe Thread e criando uma instância chamada “guruThread1” e criando um thread.
• Linha de código 10: Aqui estamos instanciando a classe Thread e criando uma instância chamada “guruThread2” e criando um thread.
• Linha de código 11: Estamos iniciando o tópico, ou seja, guruThread1.
• Linha de código 12: Estamos iniciando o tópico, ou seja, guruThread2.
• Linha de código 13: Exibindo o texto como "Os nomes dos threads estão a seguir:"
• Linha de código 14: Obtendo o nome do encadeamento 1 usando o método getName() da classe do encadeamento.
• Linha de código 15: Obtendo o nome do encadeamento 2 usando o método getName() da classe do encadeamento.

Saída:

Os nomes dos threads estão sendo emitidos aqui como

• Guru1
• Guru2

• Um que implementará a interface executável e
• Outro que terá o método main 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();
  }
 }
}

• Linha de código 2: Aqui estamos pegando uma classe “GuruThread2” que terá o método main nela.
• Linha de código 4: Aqui estamos pegando um método main da classe.
• Linha de código 6-7: Aqui estamos criando uma instância da classe GuruThread3 (que é criada nas linhas abaixo do código) como “threadguru1” e estamos iniciando o thread.
• Linha de código 8-9: Aqui estamos criando outra instância da classe GuruThread3 (que é criada nas linhas abaixo do código) como “threadguru2” e estamos iniciando o thread.
• Linha de código 11: Aqui estamos criando uma classe “GuruThread3” que está implementando a interface executável (ela deve ser implementada por qualquer classe cujas instâncias devem ser executadas pela thread.)
• Linha de código 13-14: estamos pegando duas variáveis ​​de classe das quais uma é do tipo classe thread e outra da classe string.
• Linha de código 15-18: estamos substituindo o construtor GuruThread3, que recebe um argumento como tipo de string (que é o nome da thread) que é atribuído à variável de classe guruname e, portanto, o nome da thread é armazenado.
• Linha de código 20: Aqui estamos substituindo o método run() da interface executável.
• Linha de código 21: Estamos gerando o nome do encadeamento usando a instrução println.
• Linha de código 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 encadeamento e também fazendo o encadeamento dormir por 1.000 milissegundos dentro de um bloco try-catch, pois o método sleep levantou uma exceção verificada.
• Linha de código 33: Aqui estamos substituindo o método start da interface executável.
• Linha de código 35: Estamos gerando o texto "Tópico iniciado".
• Linha de código 36-40: Aqui estamos tomando uma condição if para verificar se a variável de classe guruthread tem valor nela ou não. Se for nulo, estamos criando uma instância usando a classe de thread que recebe o nome como parâmetro (valor para o qual foi atribuído no construtor). Depois disso, o encadeamento é iniciado usando o método start().

Saída :

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

Obtemos os nomes do encadeamento conforme os produzimos.

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

O loop é executado três vezes e entre o encadeamento é suspenso por 1000 milissegundos.

Portanto, primeiro, temos guru1, depois guru2, depois novamente guru2 porque o thread dorme aqui por 1.000 milissegundos e, em seguida, guru1 e novamente guru1, o thread dorme por 1.000 milissegundos, então temos guru2 e depois guru1.

Resumo

• Explicar o multithreading em Java:no multithreading, os usuários não são bloqueados, pois os threads são independentes e podem realizar várias operações ao mesmo tempo
• Vários estágios do ciclo de vida do segmento são,
  • Novo
  • Executável
  • Correndo
  • Aguardando
  • Morto
• Também aprendemos sobre sincronização entre threads, o que ajuda o aplicativo a funcionar sem problemas.
• A programação multithread em Java facilita muito mais tarefas de aplicativos.