Método Wait () em Java

Neste artigo, veremos o método wait() para controlar o thread e os métodos notify() / notifyAll() . Esses métodos são definidos na classe base java.lang.Object e, consequentemente, os mecanismos de herança que estão em Java fornecem esses métodos para absolutamente todas as classes. Ou seja, quando você cria sua própria classe e seus objetos, sempre pode chamar esses métodos.

Como funcionam os métodos wait() e notify()/notifyAll()?

• espere() . em resumo, esse método libera o monitor e coloca o thread de chamada em um estado de espera até que outro thread chame o método notify() / notifyAll() ;
• notificar() . Continua o trabalho de um thread cujo método wait() foi chamado anteriormente;
• notifyAll() retoma todos os encadeamentos que tiveram seu método wait() chamado anteriormente.

Agora vamos dar uma olhada mais de perto no método wait() . A classe Object contém três opções para este método:

• public final native void wait(long timeoutMillis) throws InterruptedException ; Isso faz com que o thread atual espere até ser ativado. Geralmente isso acontece ao ser notificado ou interrompido, ou até que uma certa quantidade de tempo real tenha decorrido.

• public final void wait() lança InterruptedException . Não é por acaso que escrevemos um método sem parâmetros como o segundo. Na verdade, se você olhar seu código, ele se refere à primeira variante do método, tem apenas o argumento 0L.

• espera final pública (long timeout, int nanos) . Faz com que o thread atual espere até ser ativado, normalmente por ser notificado ou interrompido, ou até que uma certa quantidade de tempo real tenha decorrido.

O método wait () destina-se a suspender o thread de chamada. O que isso significa? Esses métodos pertencem à classe. Com base na classe, você cria um objeto. Objetos existem em alguns threads. Ou seja, os objetos são criados em algumas threads. No thread em que este objeto funciona, se você chamar wait() nele, isso levará ao fato de que este thread será interrompido. O próprio objeto atua como uma espécie de monitor. O que é? É claro que você pode criar objetos diferentes e todos eles conterão o wait()método. Há um entendimento de qual objeto causou a parada de um determinado segmento. O thread para e espera enquanto estiver escrito no parâmetro. E então vai começar. Este segmento não pode iniciar sozinho. Para retomar o trabalho, existem os métodos notify e notifyAll. Uma chamada para notify() ou notifyAll() deve reproduzir algum outro thread. Com wait() , você pode parar vários threads e iniciar todos os threads com notifyAll() . Se várias threads foram interrompidas e notify() foi chamado, é impossível dizer exatamente qual thread retomará esse método. Se não houver threads em espera no método wait() , nada acontecerá quando notify() ounotifyAll() é chamado. Um thread pode chamar os métodos wait() ou notify() em um objeto específico somente se ele tiver um bloqueio nesse objeto. wait() , notify() e notifyAll() só devem ser chamados a partir do código sincronizado.

Exemplo de método Wait()

Aqui temos um dos exemplos mais populares que ilustra como o método funciona. Digamos que temos uma loja, um produtor e um consumidor. O fabricante transfere alguns produtos de produção para a loja, após o que o consumidor pode levá-los. Suponha que o fabricante tenha que produzir 8 bens, respectivamente, o consumidor deve comprar todos eles. Mas, ao mesmo tempo, não podem haver mais de 6 itens no depósito ao mesmo tempo. Para resolver este problema, usamos os métodos wait() e notify() . Vamos definir três classes: Market , Manufacturer e Client . O Manufacturer no método run() adiciona 8 produtos ao objeto Market usando seumétodo put() . O cliente no método run() em um loop chama o método get do objeto Market para obter esses produtos. Os métodos put e get da classe Market são sincronizados. Para rastrear a presença de mercadorias na classe Market , verificamos o valor da variável item. O método get() para obter um produto só deve ser acionado se houver pelo menos um produto. Portanto, no método get, verificamos se o produto está faltando. Se o item não estiver disponível, o método wait() é chamado. Este método libera o monitor do objeto Market e bloqueia o método get até que o notify()método é chamado no mesmo monitor. Quando um item é adicionado ao método put() e o notify() é chamado, o método get() obtém o monitor. Depois disso, nosso cliente recebe um item. Para isso, uma mensagem é exibida e o valor do item é decrementado. Por fim, a chamada do método notify() sinaliza ao método put() para continuar. No método put() , uma lógica semelhante funciona, só que agora o método put() deve funcionar se não houver mais de 6 produtos no Market .

class Market {

   private int item = 0;

   public synchronized void get() {
       //here we use wait() method
       while (item < 1) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item--;
       System.out.println("A client has bought 1 item...");
       System.out.println("Items quantity in Market warehouse... " + item);
       notify();
   }

   public synchronized void put() {
       //here we use wait() method when the Warehouse is full
       while (item >= 6) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item ++;
       System.out.println("Manufacturer has added 1 more item...");
       System.out.println("Now there are " + item + " items in Warehouse" );
       notify();
   }
}

class Manufacturer implements Runnable {

   Market market;

   Manufacturer(Market market) {
       this.market = market;
   }


   public void run() {
       for (int i = 0; i < 8; i++) {
           market.put();
       }
   }
}

class Client implements Runnable {

   Market market;
   Client(Market market) {
       this.market = market;
   }
   public void run() {
       for (int i = 0; i < 8; i++) {
           market.get();
       }
   }
}
//wait() method test class
public class WaitTest {
   public static void main(String[] args) {

       Market market = new Market();
       Manufacturer manufacturer = new Manufacturer(market);
       Client client = new Client(market);
       new Thread(manufacturer).start();
       new Thread(client).start();
   }
}

Aqui, usando wait() no método get() , estamos esperando que o Manufacturer adicione um novo item. E depois de adicionar, chamamos notify() , como se disséssemos que um lugar ficou livre no Warehouse , e você pode adicionar mais. No método put() , utilizando wait() , estamos aguardando a liberação de espaço no Warehouse . Depois que o espaço estiver livre, adicionamos o item, notify() inicia a thread e o Cliente pode pegar o item. Aqui está a saída do nosso programa: