package com.zxl.thread.notify;
/** *//**
 * 
 * @author zhangxl
 *
 */
public class SynThread1 extends Thread {
    
    private Object lockObj;
    private volatile int i = 0;
    public SynThread1(Object lockObj){
        this.lockObj = lockObj;
    }

    public void run(){
        
        synchronized(lockObj){
            while(true){
                if(i==0){
                    try {
                        System.out.println(Thread.currentThread().getName()+" will be waiting.");
                        lockObj.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                System.out.println(Thread.currentThread().getName()+": i="+i);
                //i++;
                
                if(i>=1) return;
            }
        }
    }
    
    public static void  main(String[] arg){
        
        Object lock = new Object();
        
        SynThread1 t1 = new SynThread1(lock);
        t1.setName("SynThread_1");
        SynThread1 t2 = new SynThread1(lock);
        t2.setName("SynThread_2");
        t2.start();
        t1.start();
        
        
        
        try {
            Thread.sleep(1000);
            
            synchronized(lock){
                lock.notify();    //通过结果观察，sun JVM(hotspot)的通知机制极有可能是FIFO的策略，原因是t1、t2只要谁先启动，谁就将被唤醒。
            }
        } catch (InterruptedException e) {
            // TODO Aut o-generated catch block            e.printStackTrace();
        }
    }
}

package com.zxl.thread.notify;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionThread implements Runnable {
 
 
 
 private ReentrantLock lock;
 
 private Condition c;
 
 private volatile int i=0;
 
 public ConditionThread(ReentrantLock lock){
  this.lock = lock;
  c = lock.newCondition();
 }

 public void run() {
  
  lock.lock();
  
  try{
   
   while(true){
    if(i==0){
     System.out.println(Thread.currentThread().getName()+" will be waiting...");
     c.await();
    }
    
    System.out.println(Thread.currentThread().getName()+" is already waked up,i="+i);
    
    if(i>=1) return;
   }
   
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  finally{
   lock.unlock();
  }
  
  
  
 }
 
 public Condition getCondition(){
  return c;
 }
 
 public static void main(String[] args){
  
  
  
  ReentrantLock lock = new ReentrantLock();
  ConditionThread ct1 = new ConditionThread(lock);
  ConditionThread ct2 = new ConditionThread(lock);
  Thread t1 = new Thread(ct1);
  t1.setName("C_Thread_1");
  Thread t2 = new Thread(ct2);
  t2.setName("C_Thread_2");
  
  t1.start();
  t2.start();
  
  try {
   Thread.sleep(1000);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  
  lock.lock();
  ct1.getCondition().signal();   //唤醒第一个线程
  lock.unlock();
 }

}