1. Compreendendo os métodos wait(), notify() e notifyAll()

Os métodos wait(), notify() e notifyAll() são essenciais para o modelo de simultaneidade Java. Eles pertencem à classe Object, que é a raiz da hierarquia de classes em Java. Isso significa que cada classe em Java herda esses métodos da classe Object.

1.1 A Classe do Objeto

A classe Object é a superclasse de todas as classes em Java. Ele fornece um conjunto de métodos básicos que cada classe herda, incluindo toString(), equals() e hashCode(). Os métodos wait(), notify() e notifyAll() também fazem parte desta classe, permitindo que threads se comuniquem e coordenem suas atividades.

1.2 O papel de wait(), notify() e notifyAll()

• wait(): Este método faz com que o thread atual espere até que outro thread invoque notify() ou notifyAll() no mesmo objeto. Deve ser chamado de dentro de um bloco ou método sincronizado.
• notify(): Este método ativa uma única thread que está aguardando no monitor do objeto (o bloqueio da thread). Se vários threads estiverem aguardando, um deles será escolhido arbitrariamente.
• notifyAll(): Este método ativa todos os threads que estão aguardando no monitor do objeto. Isso é útil quando vários threads precisam ser informados sobre uma mudança de estado.

2. Usando wait(), notify() e notifyAll() na prática

Para entender como esses métodos funcionam, vejamos alguns exemplos práticos.

2.1 Código de exemplo

Aqui está um exemplo simples que demonstra o uso destes métodos:

class SharedResource {
    private boolean available = false;

    public synchronized void consume() throws InterruptedException {
        while (!available) {
            wait(); // Wait until the resource is available
        }
        // Consume the resource
        System.out.println("Resource consumed.");
        available = false;
        notify(); // Notify that the resource is now unavailable
    }

    public synchronized void produce() {
        // Produce the resource
        available = true;
        System.out.println("Resource produced.");
        notify(); // Notify that the resource is available
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

        Thread producer = new Thread(() -> {
            try {
                while (true) {
                    Thread.sleep(1000); // Simulate time to produce
                    resource.produce();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                while (true) {
                    resource.consume();
                    Thread.sleep(2000); // Simulate time to consume
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();
    }
}

2.2 Resultados de demonstração

No exemplo acima:

• O thread do produtor produzirá periodicamente um recurso e notificará o consumidor.
• O encadeamento do consumidor aguardará até que o recurso esteja disponível, consumirá-o e notificará o produtor, se necessário.

Você verá a seguinte saída indicando as operações de produtor e consumidor:

Resource produced.
Resource consumed.
...

Esta saída demonstra como wait(), notify() e notifyAll() coordenam a interação produtor-consumidor.

3.Conclusão

Ao entender a qual classe os métodos wait(), notify() e notifyAll() pertencem e como eles funcionam, você pode gerenciar com eficiência comunicação entre threads em seus aplicativos Java. Esses métodos são essenciais para garantir que os threads cooperem e compartilhem recursos de forma eficiente.

Se você tiver alguma dúvida ou precisar de mais esclarecimentos, fique à vontade para deixar um comentário abaixo!

Leia mais postagens em: A qual classe pertencem os métodos wait(), notify() e notifyAll()?