线程wait-notify-notifyAll

wait-notify-notifyAll

1. 每一个对象除了有一个锁之外，还有一个等待队列（waitset），当一个对象刚创建的时候，它的等待队列是空的；
2. 我们应该在当前线程锁住对象的锁后，去调用该对象的wait方法；
3. 当调用对象的notify方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程；
4. 当调用对象的notifyAll方法时，将从该对象的等待队列中删除所有等待的线程，这些线程成为可运行的线程；
5. wait和notify主要用于producer-consumer这种关系中；
   

---

// 同一个队列，一个放，一个取；
class Test{
    public static void main(String[] args){
        Queue q = new Queue();

        Product p = new Product(q);
        Customer c= new Customer(q);
        p.start();
        c.start();

    }
}
class Customer extends Thread{
    Queue q;
    Customer(Queue q){
        this.q = q;
    }
    public void run(){
        while(true){
            System.out.println("Customer get:"+q.get());
        }
    }
}
class Product extends Thread{
    Queue q;
    Product(Queue q){
        this.q = q;
    }
    public void run(){
        for(int i=0;i<10;i++){
            q.put(i);
            System.out.println("Product put:"+i);
        }
    }
}

class Queue{
    // 注意：wait 与 notify 要在同一个对象里面
    int value;
    boolean bFull = false;
    public synchronized void put(int i){
    // 需要在同步的环境处理“synchronized”
        if(!bFull){         
            value = i;
            bFull = true;
            notify();// 通知get可以取了                           
        }
        try{
            wait();// 没取当前值时，继续等待。不能继续放值；由于wait有异常抛出必须捕获
        }catch(Exception e){
            e.printStackTrace();
        }

    }
    public synchronized int get(){
        if(!bFull){
            try{
                wait();
            }catch(Exception e){
                e.printStackTrace();
            }

        }
        notify();       
        bFull = false;
        return value;
    }
}