Introdução ao ciclo de vida do encadeamento em Java
Um encadeamento experimenta várias fases do ciclo de vida. Tais como, um segmento vem ao mundo, começou, corre e depois desaparece. O diagrama subseqüente explica o ciclo de vida completo da rosca.
- O Construtor de segmentos produz um segmento através de um novo estado.
- A chamada para iniciar o método no Thread pode passar pelo estado executável.
- O Agendador de Encadeamentos referente a Java executa esse encadeamento quando o processador recebe.
- Quando o encadeamento entra em um estado bloqueado, ele é executado novamente porque volta ao estado executável.
- Se o método de espera for referido como o encadeamento aguardaria o estado, ele passaria ao estado executável logo após se tornar uma notificação em todo o Inform e um método de notificação para todos.
- O segmento termina assim que o método run termina.
O que é Thread?
Um encadeamento é definido no nível do sistema operacional. E a linguagem Java, assim como todas as outras linguagens, usa, aproveita o serviço fornecido pelo sistema operacional. Do ponto de vista do desenvolvedor, um encadeamento é um conjunto de instruções que vamos escrever em nosso aplicativo e executar de uma certa maneira. Um aplicativo em si pode ser composto de vários threads. Threads diferentes podem ser executados ao mesmo tempo. A JVM (Java Virtual Machine) trabalha com vários encadeamentos. Existem threads para a coleta de lixo. Existem threads para o Just in Time Compiler e outros threads técnicos.
Estados do ciclo de vida do encadeamento em Java
Abaixo estão os diferentes estados do ciclo de vida do encadeamento em Java:
1. Novo: um novo encadeamento inicia seu ciclo de vida dentro do novo estado. Ele continua nesse estado antes do programa iniciar o encadeamento. Além disso, é conhecido como um thread criado.
2. Runnable: Depois que um thread recém-nascido pode começar, o thread se torna runnable. Um encadeamento com esse estado é considerado executando seu processo.
3. Aguardando: Ocasionalmente, ocorre uma transição de encadeamento para a espera em todo o estado, mesmo que o encadeamento aguarde outro encadeamento para executar uma atividade. Um encadeamento transita retornando ao estado executável apenas se um encadeamento adicional indicar o encadeamento em espera para continuar executando.
4. Espera cronometrada : Um encadeamento executável pode latar facilmente a espera cronometrada específica para que o estado obtenha um intervalo específico de tempo. Um encadeamento com esse estado transita retornando ao estado executável quando esse intervalo de pontos expirar ou se o evento que ele realmente está aguardando acontecer.
5. Finalizado: um thread executável entra no estado finalizado porque realiza sua tarefa ou finaliza.
Como criar um thread em Java?
A maneira mais básica de criar um encadeamento em Java é usar o Padrão Runnable. Você precisa primeiro criar uma instância da interface Runnable, o que é muito fácil; existe apenas um método para implementar. Depois, passamos essa instância para o construtor da classe Thread. E então chamamos o método start () deste objeto de thread criado, para iniciar um novo thread que executará a tarefa agrupada em nosso objeto Runnable.
Então, primeiro criamos uma instância de um Runnable. Existe apenas um método para implementar, chamado método run (). Este é o padrão Java 7 para fazer isso, com uma instância de uma classe anônima. Mas também podemos usar uma expressão lambda para implementar um Runnable, pois existe apenas um método na interface Runnable.
Vamos criar threads em exemplos muito simples
Vamos ver o que pode dar errado com uma condição de corrida que é com código não sincronizado que deve ser sincronizado e vamos corrigir nosso código usando a sincronização. Este primeiro exemplo é muito simples, é muito básico. É apenas sobre a criação de uma tarefa.
Resultado:
Uma tarefa é uma instância da interface Runnable, vamos chamá-la de executável, e podemos implementar essa interface usando uma expressão lambda. Esta tarefa é dada a um novo encadeamento e executada no contexto desse encadeamento. Então, apenas imprimiremos o nome do thread que está executando esta tarefa. Estou executando em… Thread.currentThread () é um método estático da classe Thread que retorna o thread executando a tarefa atual. E nós apenas temos que chamar getName () neste objeto de thread para retornar o nome de um thread. Depois, criamos uma instância de Thread t = new Thread. Passando este executável como um parâmetro. Portanto, este segmento irá executar este pedaço de código. E para lançá-lo. t.start () este é o método start () que precisamos chamar. O que também podemos fazer é fornecer um nome explícito para este Thread usando t.setName ("My thread"). E agora podemos executar esse código. Agora, em vez de chamar o método start (), chamamos o método run () e, se executarmos esse código, o problema é que a tarefa é executada corretamente, mas não é executada no thread que criamos. É executado no thread principal, que é o thread que executa o método principal. Portanto, este método run () não deve ser chamado se queremos iniciar um novo thread.
Resultado:
Métodos do ciclo de vida do encadeamento em Java
Os métodos descritos simplesmente pelo Thread são apresentados na Tabela.
| Tipos de dados | Nomes dos métodos de encadeamento |
| Corda |
getName () Retornar o nome deste segmento |
| int | obtenha prioridade ()
Retorna a prioridade do encadeamento |
| boleano | Está vivo()
Testa se este encadeamento ainda está em execução |
| vazio | Junte-se()
Aguarda que este encadeamento morra (encerre) |
| vazio | corre()
Sempre que esse encadeamento foi criado utilizando um objeto Runnable individual, depois daquele que normalmente é chamado o método run do objeto Runnable; ou então, esse método não será tão bom quanto, retorna. Sempre que a classe de encadeamento puder ser estendida, bem como, o método run () for substituído durante a subclasse, um método run () substituído será chamado. |
| vazio | setName ( nome da sequência )
Altera o nome com este encadeamento para se tornar comparável ao nome do argumento. |
| vazio estático | sono ( milissegundos ) lança Interrupção / Exceção Faz com que o encadeamento atualmente em execução fique parado por a quantidade necessária de milissegundos. |
| vazio estático | sleep ( millis longos, int nanos ) lança InterruptedException
Faz com que o encadeamento atualmente em execução seja suspenso (interromper a execução) para a quantidade necessária de milissegundos, bem como a quantidade específica de nanossegundos. |
| vazio | começar()
Dispara esses encadeamentos para iniciar a execução; a Java Virtual Machine chama o método run desse encadeamento. |
| vazio estático | produção()
Dispara o objeto de encadeamento atualmente para pausar brevemente e permitir a execução de encadeamentos adicionais. |
| Thread estático | currentThread ()
Retorna uma menção ao objeto de encadeamento atualmente em execução. |
Conclusão
- Simples de começar a usar threads, extremamente difícil de entender.
- Projetar classes que contêm métodos que podem ser seguros para threads é um desafio.
- Leia: JavaDoc para obter a classe java.lang.Thread
Artigo recomendado
Este foi um guia para o ciclo de vida do encadeamento em Java. Aqui discutimos o que é thread? e diferentes estados do ciclo de vida do encadeamento, juntamente com a criação de encadeamentos em java. Você também pode consultar nossos outros artigos sugeridos para saber mais -
- Estruturas em Java
- Padrões de estrelas em Java
- Mesclar classificação em Java
- Melhores compiladores Java
- Método estático em PHP