O objetivo da comunicação de threads é permitir que os threads enviem sinais um para o outro. Além disso, a comunicação de threads também pode fazer com que o thread aguarde sinais de outros threads. Por exemplo, o thread B pode aguardar sinais do thread A, que pode ser um sinal de que o thread a processou e concluído.
Método Wait ()
- Interrompa a execução do método, faça com que este tópico espere, desista temporariamente do direito de usar a CPU e permita que outros threads usem esse método de sincronização
Notify () método
-Wake up esperando em um certo fim do tópico de espera devido ao uso desta festa síncrona
NotifyAll () método
Acorde todos os tópicos esperando o final da espera devido ao uso deste método de sincronização
Quando usar o método de espera
Quando uma variável é usada no método de sincronização usado por um encadeamento, e essa variável precisa ser modificada por outros threads para atender às necessidades deste thread, você pode usar o método Wait () no método de sincronização
Aqui vou dar um exemplo na classe como um exemplo para descrever brevemente o papel da espera e notificar
Já sabemos que, na multi-threading, como a venda de ingressos, a ordem dos ingressos vendidos em cada janela é aleatória. Se tivermos 2 bilhetes que vendem janelas, é estipulado que 100 ingressos devem ser vendidos por sua vez. Depois de vender um ingresso na janela A, o próximo ticket deve ser vendido pela janela B. Como implementamos essa função?
Primeiro de tudo, acho que se a declaração puder ser definida. Se (i%2 == 0), o thread 1 executa, caso contrário, o thread 2 é executado, mas as execuções do thread 1 e do thread 2 são aleatórias e não poderá ser especificado para determinar quem é executado pelo tamanho de i.
Então podemos usar wait () e notificar () no tópico
Depois que o thread 1 termina, espere um momento, depois o thread 2 está em execução e depois que o thread 2 é concluído, depois acorde o thread 1 e depois novamente
Depois que o thread 1 terminar, espere um momento, o Thread 2 é executado e após o thread 2 terminar, depois acorde o thread 1
Dessa forma, o thread 1 e o thread 2 podem ser executados por sua vez
Imprimimos 10 números como exemplos para escrever um programa e construímos um total de 2 classes myprint e myprinttest.
Myprint.java
public class Myprint implementa runnable {private int i = 0; @Override public void run () {try {print ();} Catch (interruptedException e) {// TODO BLOCO DE CATO GONERADO AUTO InterruptEdException {while (i <10) {System.out.println (thread.currentThread (). GetName ()+":"+i); i ++; notify (); tente {wait ();} catch (interruptException e) {e.printstacktrace ();}}}}Os resultados são mostrados na figura
Você pode ver que o thread 1 e o thread 2 foram implementados para imprimir alternadamente entre si.
Apenas entenda o processo de execução
enquanto (i <10) {System.out.println (thread.currentThread (). getName ()+":"+i); i ++; notify (); try {wait ();} catch (interruptedException e) {e.printStacktrace ();}}}}}Quando eu <10, imprima thread 1 e depois execute o despertar. Como não há thread na frente, esta etapa não é executada. Em seguida, o thread 1 espera. Depois de executar o thread 2, acorda o tópico anterior, ou seja, thread 1, e depois imprime o thread 1,
Esse processo continua até que o loop quebre, para que possamos realizar rotações
Resumir
O exposto acima é o conteúdo inteiro deste artigo sobre discutir brevemente o papel da espera e notificar na comunicação de threads. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!