Diferença chave - 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 o 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 Método notificationAll para o objeto.
Um thread é a menor unidade de processamento no sistema operacional. É um único fluxo de controle sequencial dentro de um programa. Os tópicos são leves. Multithreading é o mecanismo de execução de vários threads ao mesmo tempo. Linguagens de programação como Java oferecem suporte a multithreading. Multithreading tem vantagens porque permite executar vários threads simultaneamente e os threads são independentes uns dos outros. Existem métodos em Java que podem ser usados para multithreading. Dois deles estão dormindo e esperando.
CONTEÚDO
1. Visão geral e principais diferenças
2. O que é dormir em Java
3. O que é esperar em Java
4. Semelhanças entre dormir e esperar em Java
5. Comparação lado a lado - dormir vs esperar em Java na forma tabular
6. Resumo
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 threads e há uma troca de contexto ocorrendo entre esses threads. Em Java, existem duas maneiras de criar um encadeamento. Isto é, 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 sejam executadas por um thread. Quando o thread é executado, o código que deve ser executado é escrito dentro do método run. O thread que deve ser executado é selecionado pelo planejador de thread. Apenas um thread é executado em um único processo.
Um segmento passa por várias fases. Depois de criar um objeto da classe Thread, o programador pode invocar o método start. Antes de invocar esse método, diz-se que o encadeamento está no novo estado. O planejador de thread seleciona um thread para execução. Se o encadeamento ainda não foi selecionado pelo planejador de encadeamento, mas se o método de início for invocado, o encadeamento está em um estado executável. Depois que o planejador de thread seleciona o thread a ser executado, ele passa para o estado de execução. Se o encadeamento estiver ativo, mas não elegível para execução, ele está em um estado bloqueado ou não executável. Após a conclusão do método run, a thread vai para o estado finalizado. Essas são as principais fases do ciclo de vida do segmento.
Existem vários métodos disponíveis na classe thread para executar diferentes tarefas. O método do sono é usado para dormir o método por um período específico de tempo. A sintaxe para o método sleep é public void sleep (long milissegundos) lança InterruptedException. Isso faz com que o thread em execução no momento 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 é limpo quando essa exceção é lançada.
Figura 01: Programa Java com método de sono
De acordo com o programa acima, o método run contém o código que deve ser executado. No programa principal, dois objetos do ExampleThread1 são criados e os métodos de início são invocados neles. Isso permitirá executar o código dentro do método run. Apenas um thread é executado por vez. Com o Tópico. sono (1000); permitirá que o primeiro thread termine a execução por 1000 milissegundos. Quando um thread está inativo, o planejador de thread seleciona o outro thread.
O que é esperar em Java?
Vários threads podem acessar um recurso compartilhado. Isso pode causar a geração de uma saída incorreta. A sincronização de threads pode ser usada para fazer com que apenas uma thread acesse o recurso compartilhado. Considere a seguinte situação. Se houver dois threads como t1 e t2, t1 começará a salvar valores em um arquivo de texto denominado Text1.txt. Esses valores serão usados para algum outro cálculo quando t1 retornar. Se t2 começar 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, de forma que é 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 é concluída, o t1 pode liberar o bloqueio. O bloqueio também é conhecido como monitor.
A sincronização de threads pode ser alcançada 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. É implementado usando os métodos wait, notifique e notifiqueAll. Eles pertencem à classe Object. O método wait é usado para permitir que o encadeamento atual libere o bloqueio e espere até que outro encadeamento invoque o método notificar ou notificarAll para o objeto. O método de notificação é usado para ativar um único encadeamento que está aguardando o bloqueio. O NoticeAll desperta todos os threads que estão esperando pelo bloqueio.
Figura 02: Classe da calculadora
Figura 03: Método Principal
A classe Calculator estende o Thread. O bloco sincronizado está dentro do método run. O loop for e o método de notificação estão dentro do bloco sincronizado. Dentro do método principal, uma instância de um thread é criada e o método de início é chamado nessa instância. O método principal irá esperar até que o tópico forneça uma notificação. Ao executar o programa, o método principal espera até a execução completa do método run e espera pelo método de notificação. Depois 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 um bloco sincronizado e se o método principal tiver um código como abaixo, ele dará a saída como zero porque não está aguardando a conclusão do outro thread.
Calculadora t1 = nova Calculadora ();
t1. start ();
System.out.println (t1.sum);
Qual é a semelhança entre dormir e esperar em Java?
Sleep e wait são métodos que podem ser usados ao implementar multithreading em Java
Qual é a diferença entre dormir e esperar em Java?
Artigo Diff meio antes da tabela
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 cronômetros e agendadores do sistema. | O método wait faz com que o encadeamento atual espere até que outro encadeamento invoque o método notificar ou notificarAll para o objeto. |
| Associação com Fechadura | |
| O método sleep não libera o bloqueio de um objeto durante a sincronização. | O método de espera libera o bloqueio durante a sincronização. |
| Método de execução | |
| O método sleep é executado no thread atual. | O método de espera é 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 terminar. | O método de espera é interrompido pela chamada dos métodos notificar ou notificarAll. |
Resumo - dormir x 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 oferece suporte a multithreading. Ele permite a execução de vários threads simultaneamente. O sleep e wait são dois métodos que podem ser usados ao implementar multi-threading. A diferença entre sleep e wait em Java é que o 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 notificar ou notificarAll método para o objeto.
