3.2notify和notifyAll

notify一次只能通知一个wait线程，有多少个wait就需要多少个notify，如果少了，就会出现有线程因为没有通知而一直处于wait。这个时候可以使用notifyAll

package com.myObject;

public class Object3 {

    public void mothd1(Object lock) {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName()+" wait begin " + System.currentTimeMillis());
                lock.wait();
                System.out.println(Thread.currentThread().getName()+" wait end " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public void mothd2(Object lock) {
        synchronized (lock) {
            System.out.println(Thread.currentThread().getName()+" notify begin " + System.currentTimeMillis());
            lock.notifyAll();
            System.out.println(Thread.currentThread().getName()+" notify end " + System.currentTimeMillis());
        }

    }
}

package com.myThread;

import com.myObject.Object3;

public class Thread3c extends Thread {
    Object lock;
    Object3 object3 = new Object3();

    public Thread3c(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        object3.mothd2(lock);
    }
}

package com.myThread;

import com.myObject.Object3;

public class Thread3b extends Thread {
    Object lock;
    Object3 object3 = new Object3();

    public Thread3b(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        object3.mothd1(lock);
    }
}

package com.myThread;

import com.myObject.Object3;

public class Thread3a extends Thread {
    Object lock;
    Object3 object3 = new Object3();

    public Thread3a(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        object3.mothd1(lock);
    }
}

package com.test;

import com.myThread.Thread3a;
import com.myThread.Thread3b;
import com.myThread.Thread3c;

public class Test3 {
    public static void main(String[] args) throws InterruptedException{
        Object lock = new Object();
        Thread3a thread3a = new Thread3a(lock);
        thread3a.setName("A");
        thread3a.start();
        Thread.sleep(1000);
        Thread3b thread3b = new Thread3b(lock);
        thread3b.setName("B");
        thread3b.start();
        Thread.sleep(1000);
        Thread3c thread3c = new Thread3c(lock);
        thread3c.setName("C");
        thread3c.start();

    }
}

打印结果

A wait begin 1453100184721
B wait begin 1453100185722
C notify begin 1453100186723
C notify end 1453100186723
B wait end 1453100186724
A wait end 1453100186724

分析：notifyAll（）会让所有因为wait（）而进入阻塞队列的线程进入就绪队列，然后一起竞争通知对象的资源。并且注意无论使用notify（）还是notifyAll（）不要通知过早，而使得wait（）没有被通知