Key Difference – dormir vs esperar em Java
Sleep e wait são dois métodos usados para multithreading em Java. O método sleep pertence à classe Thread enquanto o método wait é da classe Object. A principal diferença entre sleep e wait em Java é que, sleep é usado para suspender a execução do thread atual pelo número especificado de milissegundos enquanto o método wait é usado para fazer com que o thread atual espere até que outro thread invoque a notificação ou notifyAll método para o objeto.
Um thread é a menor unidade de processamento no sistema operacional. É um único fluxo sequencial de controle dentro de um programa. Os fios são leves. Multithreading é o mecanismo de execução de vários threads ao mesmo tempo. Linguagens de programação como Java suportam multithreading. O multithreading tem vantagens porque permite executar várias threads simultaneamente e as threads são independentes umas das outras. Existem métodos em Java que podem ser usados para multithreading. Dois deles são dormir e esperar.
O que é dormir em Java?
Existem vários processos em execução em um sistema operacional. Um processo é um programa em execução. Cada processo pode ter vários encadeamentos e há uma troca de contexto ocorrendo entre esses encadeamentos. Em Java, existem duas maneiras de criar um thread. Isso é estendendo a classe de thread ou implementando a interface Runnable. A classe Thread tem construtores e métodos para criar e executar operações em um thread. A classe Thread estende a classe Object e implementa a interface Runnable. A interface Runnable deve ser implementada por qualquer classe cujas instâncias devem ser executadas por um thread. Quando a thread é executada, o código que deve ser executado é escrito dentro do método run. O encadeamento que deve ser executado é selecionado pelo agendador de encadeamentos. Apenas um thread é executado em um único processo.
Um thread passa por várias fases. Após criar um objeto da classe Thread, o programador pode invocar o método start. Antes de invocar esse método, diz-se que a thread está no novo estado. O agendador de encadeamentos seleciona um encadeamento a ser executado. Se o encadeamento ainda não estiver selecionado pelo agendador de encadeamentos, mas se o método start for invocado, o encadeamento estará em um estado executável. Depois que o agendador de encadeamentos seleciona o encadeamento a ser executado, ele transita para o estado de execução. Se o thread estiver ativo, mas não estiver qualificado para execução no momento, ele estará no estado não executável ou bloqueado. Após a conclusão do método run, o thread vai para o estado finalizado. Essas são as principais fases do ciclo de vida da thread.
Existem vários métodos disponíveis na classe thread para realizar diferentes tarefas. O método sleep é usado para dormir o método por um período de tempo específico. A sintaxe para o método sleep é public void sleep (longos milissegundos) lança InterruptedException. Isso faz com que o thread atualmente em execução pare a execução temporariamente por um número especificado de milissegundos. Se outro encadeamento interromper o encadeamento atual, o status interrompido do encadeamento atual será apagado quando esta exceção for lançada.
Figura 01: Programa Java com Método Sleep
De acordo com o programa acima, o método run contém código que deve ser executado. No programa principal, dois objetos do ExampleThread1 são criados e os métodos start são invocados neles. Isso permitirá executar o código dentro do método run. Apenas um thread é executado por vez. Com o Fio.dormir (1000); permitirá que o primeiro thread termine a execução por 1000 milissegundos. Quando um encadeamento está dormindo, o agendador de encadeamentos pega o outro encadeamento.
O que é esperar em Java?
Vários threads podem acessar um recurso compartilhado. Pode causar a geração de uma saída incorreta. A sincronização de thread pode ser usada para fazer apenas um thread acessar o recurso compartilhado. Suponha uma situação como segue. Se houver dois encadeamentos como t1 e t2, t1 começará a salvar os valores em um arquivo de texto chamado Text1.txt. Esses valores serão usados para algum outro cálculo quando t1 retornar. Se t2 iniciar antes de t1 retornar, t2 pode alterar os valores salvos por t1. Isso pode fazer com que t1 forneça uma saída errada. Com a ajuda da sincronização, quando t1 começa a usar o arquivo Text1.txt, esse arquivo pode ser bloqueado, para que seja acessível apenas por t1. O t2 não pode alterá-lo até que t1 libere o bloqueio para acessar esse arquivo de texto. Quando a tarefa for concluída, o t1 pode liberar o bloqueio. A fechadura também é conhecida como monitor.
A sincronização de threads pode ser obtida por comunicação entre threads. Uma seção crítica é um segmento de código que acessa os recursos compartilhados. Na comunicação entre threads, uma thread é pausada em execução em sua seção crítica e outra thread pode entrar na mesma seção crítica para ser executada. Ele é implementado usando os métodos wait, notify e notifyAll. Eles pertencem à classe Object. O método wait é usado para permitir que o thread atual libere o bloqueio e espere até que outro thread invoque o método notify ou notifyAll para o objeto. O método de notificação é usado para ativar um único thread que está aguardando o bloqueio. O notifyAll ativa todos os threads que estão aguardando o bloqueio.
Figura 02: Classe da Calculadora
Figura 03: Método Principal
A classe Calculator estende a Thread. O bloco sincronizado está dentro do método run. O método for loop e notify está dentro do bloco sincronizado. Dentro do método main, uma instância de um thread é criada e o método start é chamado nessa instância. O método main irá esperar até que o thread dê uma notificação. Ao executar o programa, o método main espera até a execução completa do método run e aguarda o método notify. Uma vez que o método de notificação é chamado, o método principal para de esperar e começa a executar o resto do código. Main está esperando até que o thread da Calculadora seja concluído. Finalmente, o resultado da soma é impresso.
Se não houver nenhum bloco sincronizado e se o método main tiver um código como abaixo, ele dará a saída como zero porque não está aguardando a conclusão da outra thread.
Calculadora t1=new Calculadora ();
t1. inicio();
System.out.println (t1.sum);
Qual é a semelhança entre dormir e esperar em Java?
Tanto sleep quanto wait são métodos que podem ser usados ao implementar multithreading em Java
Qual é a diferença entre dormir e esperar em Java?
dormir vs esperar em Java |
|
| O método sleep faz com que o thread atual suspenda a execução pelo número especificado de milissegundos, sujeito à precisão e exatidão dos temporizadores e programadores do sistema. | O método wait faz com que a thread atual espere até que outra thread invoque o método notify ou notifyAll para o objeto. |
| Associação com cadeado | |
| O método sleep não libera o bloqueio de um objeto durante a sincronização. | O método wait libera o bloqueio durante a sincronização. |
| Método de Execução | |
| O método sleep é executado na thread atual. | O método wait é chamado no objeto. |
| Classe Associada | |
| O sono é um método da classe Thread. | A espera é um método da classe Object. |
| Conclusão | |
| O processo de suspensão é concluído após o período de tempo especificado. | O método wait é interrompido chamando os métodos notify ou notifyAll. |
Resumo – dormir vs esperar em Java
Existem vários processos em execução no sistema operacional. Cada processo pode ter vários threads. Um thread é a menor unidade de processamento em um sistema operacional. A linguagem de programação Java suporta multithreading. Ele permite a execução de vários threads simultaneamente. A suspensão e a espera são dois métodos que podem ser usados ao implementar o multi-threading. A diferença entre sleep e wait em Java é que, sleep é usado para suspender a execução do thread atual pelo número especificado de milissegundos enquanto o método wait é usado para fazer com que o thread atual espere até que outro thread invoque o notify ou notifyAll método para o objeto.
