Um cenário simples usando wait () e notify () em java

Posso obter um cenário simples e completo, isto é, um tutorial que sugere como isso deve ser usado, especificamente com uma Fila?

Os métodos wait()e notify()são projetados para fornecer um mecanismo para permitir que um encadeamento seja bloqueado até que uma condição específica seja atendida. Para isso, suponho que você queira escrever uma implementação de fila de bloqueio, na qual você tenha algum armazenamento fixo de elementos de tamanho fixo.

A primeira coisa que você precisa fazer é identificar as condições que você deseja que os métodos esperem. Nesse caso, você desejará que o put()método seja bloqueado até que haja espaço livre na loja e que você deseje que o take()método seja bloqueado até que haja algum elemento para retornar.

public class BlockingQueue<T> {

    private Queue<T> queue = new LinkedList<T>();
    private int capacity;

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public synchronized void put(T element) throws InterruptedException {
        while(queue.size() == capacity) {
            wait();
        }

        queue.add(element);
        notify(); // notifyAll() for multiple producer/consumer threads
    }

    public synchronized T take() throws InterruptedException {
        while(queue.isEmpty()) {
            wait();
        }

        T item = queue.remove();
        notify(); // notifyAll() for multiple producer/consumer threads
        return item;
    }
}

Há algumas coisas a serem observadas sobre a maneira pela qual você deve usar os mecanismos de espera e notificação.

Primeiro, você precisa garantir que todas as chamadas para wait()ou notify()estejam dentro de uma região sincronizada do código (com as chamadas wait()e notify()sendo sincronizadas no mesmo objeto). A razão para isso (além das preocupações de segurança de linha padrão) deve-se a algo conhecido como sinal perdido.

Um exemplo disso é que um encadeamento pode chamar put()quando a fila estiver cheia e, em seguida, verifica a condição, vê que a fila está cheia, mas antes que possa bloquear outro encadeamento está agendado. Esse segundo encadeamento take()é um elemento da fila e notifica os encadeamentos em espera de que a fila não está mais cheia. No entanto, como o primeiro encadeamento já verificou a condição, ele simplesmente chamará wait()após ser remarcado, mesmo que possa progredir.

Ao sincronizar em um objeto compartilhado, você pode garantir que esse problema não ocorra, pois a chamada do segundo encadeamento take()não poderá progredir até que o primeiro encadeamento seja realmente bloqueado.

Em segundo lugar, você precisa colocar a condição que está verificando em um loop while, em vez de uma instrução if, devido a um problema conhecido como despertares espúrios. É aqui que um segmento em espera às vezes pode ser reativado sem notify()ser chamado. Colocar essa verificação em um loop while garantirá que, se ocorrer uma ativação espúria, a condição será verificada novamente e o thread chamará wait()novamente.

Como algumas das outras respostas mencionaram, o Java 1.5 introduziu uma nova biblioteca de simultaneidade (no java.util.concurrentpacote) que foi projetada para fornecer uma abstração de nível mais alto através do mecanismo de espera / notificação. Usando esses novos recursos, você pode reescrever o exemplo original da seguinte maneira:

public class BlockingQueue<T> {

    private Queue<T> queue = new LinkedList<T>();
    private int capacity;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public void put(T element) throws InterruptedException {
        lock.lock();
        try {
            while(queue.size() == capacity) {
                notFull.await();
            }

            queue.add(element);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while(queue.isEmpty()) {
                notEmpty.await();
            }

            T item = queue.remove();
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }
}

Obviamente, se você realmente precisa de uma fila de bloqueio, use uma implementação da interface BlockingQueue .

Além disso, para coisas como essa, eu recomendo o Java Concurrency in Practice , pois abrange tudo o que você poderia querer saber sobre problemas e soluções relacionados à concorrência.

Não é um exemplo de fila, mas extremamente simples :)

class MyHouse {
    private boolean pizzaArrived = false;

    public void eatPizza(){
        synchronized(this){
            while(!pizzaArrived){
                wait();
            }
        }
        System.out.println("yumyum..");
    }

    public void pizzaGuy(){
        synchronized(this){
             this.pizzaArrived = true;
             notifyAll();
        }
    }
}

Alguns pontos importantes:
1) NUNCA faça

 if(!pizzaArrived){
     wait();
 }

Sempre use while (condição), porque

• a) os threads podem esporadicamente acordar do estado de espera sem serem notificados por ninguém. (mesmo quando o entregador da pizza não tocava a campainha, alguém decidia tentar comer a pizza.).
• b) Você deve verificar a condição novamente depois de adquirir o bloqueio sincronizado. Digamos que a pizza não dure para sempre. Você acorda, faz fila para a pizza, mas não é suficiente para todos. Se você não verificar, você pode comer papel! :) (provavelmente melhor exemplo seria while(!pizzaExists){ wait(); }.

2) Você deve segurar o bloqueio (sincronizado) antes de chamar wait / nofity. Os threads também precisam adquirir bloqueio antes de acordar.

3) Tente evitar adquirir qualquer bloqueio dentro do bloco sincronizado e tente não invocar métodos alienígenas (métodos que você não sabe ao certo o que estão fazendo). Se for necessário, tome medidas para evitar conflitos.

4) Tenha cuidado com notify (). Continue com notifyAll () até saber o que está fazendo.

5) Por último, mas não menos importante, leia Java Concurrency in Practice !

Mesmo que você tenha solicitado wait()e notify()especificamente, sinto que essa citação ainda é importante o suficiente:

Josh Bloch, Effective Java 2nd Edition , Item 69: Prefere utilitários de simultaneidade como waite notify(ênfase dele):

Dada a dificuldade de usar waite notifycorretamente, você deve usar os utilitários de simultaneidade de nível superior em vez [...] de usar waite notifydiretamente é como programar na "linguagem de montagem de simultaneidade", em comparação com a linguagem de nível superior fornecida por java.util.concurrent. Raramente, se é que existe, motivo para usar waite notifyno novo código .

Você deu uma olhada neste tutorial em Java ?

Além disso, aconselho que você evite brincar com esse tipo de coisa em software real. É bom brincar com ele para que você saiba o que é, mas a concorrência tem armadilhas em todo o lugar. É melhor usar abstrações de nível superior e coleções sincronizadas ou filas JMS se você estiver criando um software para outras pessoas.

É pelo menos o que eu faço. Como não sou especialista em concorrência, evito manipular os threads manualmente sempre que possível.

Exemplo

public class myThread extends Thread{
     @override
     public void run(){
        while(true){
           threadCondWait();// Circle waiting...
           //bla bla bla bla
        }
     }
     public synchronized void threadCondWait(){
        while(myCondition){
           wait();//Comminucate with notify()
        }
     }

}
public class myAnotherThread extends Thread{
     @override
     public void run(){
        //Bla Bla bla
        notify();//Trigger wait() Next Step
     }

}

Exemplo para wait () e notifyall () em Threading.

Uma lista de matriz estática sincronizada é usada como recurso e o método wait () é chamado se a lista de matriz estiver vazia. O método notify () é chamado depois que um elemento é adicionado à lista de matrizes.

public class PrinterResource extends Thread{

//resource
public static List<String> arrayList = new ArrayList<String>();

public void addElement(String a){
    //System.out.println("Add element method "+this.getName());
    synchronized (arrayList) {
        arrayList.add(a);
        arrayList.notifyAll();
    }
}

public void removeElement(){
    //System.out.println("Remove element method  "+this.getName());
    synchronized (arrayList) {
        if(arrayList.size() == 0){
            try {
                arrayList.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            arrayList.remove(0);
        }
    }
}

public void run(){
    System.out.println("Thread name -- "+this.getName());
    if(!this.getName().equalsIgnoreCase("p4")){
        this.removeElement();
    }
    this.addElement("threads");

}

public static void main(String[] args) {
    PrinterResource p1 = new PrinterResource();
    p1.setName("p1");
    p1.start();

    PrinterResource p2 = new PrinterResource();
    p2.setName("p2");
    p2.start();


    PrinterResource p3 = new PrinterResource();
    p3.setName("p3");
    p3.start();


    PrinterResource p4 = new PrinterResource();
    p4.setName("p4");
    p4.start();     

    try{
        p1.join();
        p2.join();
        p3.join();
        p4.join();
    }catch(InterruptedException e){
        e.printStackTrace();
    }
    System.out.println("Final size of arraylist  "+arrayList.size());
   }
}