Java中notify和notifyAll的区别及何时使用

import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 * Java程序演示如何在Java和Java中使用notify和notifyAll方法
  *如何通知和notifyAll方法通知线程，哪个线程被唤醒等。
 */
public class NotificationTest {
 
    private volatile boolean go = false;
 
    public static void main(String args[]) throws InterruptedException {
        final NotificationTest test = new NotificationTest();
      
        Runnable waitTask = new Runnable(){
      
            @Override
            public void run(){
                try {
                    test.shouldGo();
                } catch (InterruptedException ex) {
                    Logger.getLogger(NotificationTest.class.getName()).
                           log(Level.SEVERE, null, ex);
                }
                System.out.println(Thread.currentThread() + " finished Execution");
            }
        };
      
        Runnable notifyTask = new Runnable(){
      
            @Override
            public void run(){
                test.go();
                System.out.println(Thread.currentThread() + " finished Execution");
            }
        };
      
        Thread t1 = new Thread(waitTask, "WT1"); //will wait
        Thread t2 = new Thread(waitTask, "WT2"); //will wait
        Thread t3 = new Thread(waitTask, "WT3"); //will wait
        Thread t4 = new Thread(notifyTask,"NT1"); //will notify
      
        //starting all waiting thread
        t1.start();
        t2.start();
        t3.start();
      
        //pause to ensure all waiting thread started successfully
        Thread.sleep(200);
      
        //starting notifying thread
        t4.start();
      
    }
    /*
     * wait and notify can only be called from synchronized method or bock
     */
    private synchronized void shouldGo() throws InterruptedException {
        while(go != true){
            System.out.println(Thread.currentThread()
                         + " is going to wait on this object");
            wait(); //release lock and reacquires on wakeup
            System.out.println(Thread.currentThread() + " is woken up");
        }
        go = false; //resetting condition
    }
  
    /*
     * both shouldGo() and go() are locked on current object referenced by "this" keyword
     */
    private synchronized void go() {
        while (go == false){
            System.out.println(Thread.currentThread()
            + " is going to notify all or one thread waiting on this object");
 
            go = true; //making condition true for waiting thread
            //notify(); // only one out of three waiting thread WT1, WT2,WT3 will woke up
            notifyAll(); // all waiting thread  WT1, WT2,WT3 will woke up
        }
      
    }
}

   final Lock lock = new ReentrantLock();
   //定义2组condition 对应生产者消费者
   final Condition notFull  = lock.newCondition(); 
  
   final Condition notEmpty = lock.newCondition(); 
 
   final Object[] items = new Object[100];
   int putptr, takeptr, count;
    //在put的时候 当数组已经满了的情况下 我让线程等待 不在容纳数据 当消费者已经消费了 触发了、、
 
//notfull.signal() 这时候通知生产者 我这变已经消费了 你那边可以试试了哈。 
   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }
//同上 相反的理解就是了。。。
   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }

package com.zcd2;

public class ThreadTest1
{
    public static void main(String[] args)
    {
        Caculate caculate = new Caculate();
        
        //使用多个线程对实例caculate进行增加操作。
        for(int i = 0; i < 10; i++)
        {
            Thread1 t = new Thread1(caculate);
            t.start();
        }
        
        //使用多个线程对实例caculate进行减少操作。
        for(int i = 0; i < 2; i++)
        {
            Thread2 t = new Thread2(caculate);
            t.start();
        }
    }
}

//Thread1线程进行增加操作
class Thread1 extends Thread
{
    private Caculate caculate;
    
    public Thread1()
    {
        
    }    
    
    public Thread1(Caculate caculate)
    {
        this.caculate = caculate;
    }
    
    @Override
    public void run()
    {
        int i = 0;

        //死循环，手动停止
        while(true)
        {
            try
            {
                caculate.add();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            i++;
            System.out.println("加线程执行第 " + i + " 次");
        }
    }    
}

//Thread2进行减少操作。
class Thread2 extends Thread
{    
    private Caculate caculate;
    
    public Thread2()
    {
    }

    public Thread2(Caculate caculate)
    {
        this.caculate = caculate;
    }

    @Override
    public void run()
    {    
        int i = 0;
        
        //死循环，手动停止
        while(true)
        {
            try
            {
                caculate.sub();
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            i++;
            System.out.println("减线程执行第 " + i + " 次");
        }
    }    
}

//
class Caculate
{
    private int j = 0;    

    //增加操作
    public synchronized void add() throws InterruptedException
    {
　　　　 //当 j = 1 的时候说明不符合操作条件，要放弃对象锁。
        while(j == 1)
        {
            wait();
            System.out.println();
        }    
        j++;
        System.out.println(j);
        notify();
    }

    //减少操作
    public synchronized void sub() throws InterruptedException
    {
　　　　 //当j = 0 的时候说明不符合操作条件，放弃对象锁
        while(j == 0)
        {
            wait();
            System.out.println();
        }
        j--;
        System.out.println(j);
        notify();
    }
}