ReentrantLock 和 Condition的使用

ReentrantLock 

ReentrantLock可以等同于synchronized使用。

ReentrantLock 类实现了Lock ，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。（换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上。

Condition 

线程之间的通信。Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用。

请看demo：

/**
 *   子线程 和  主线程  协助工作
 *
 *    main  打印一次
 *    sub   打印2次
 *
* @ClassName: ThreadMutex
* @Description: TODO(这里用一句话描述这个类的作用)
* @author ZhangWei
* @date 2015年8月17日 下午5:24:54
*
 */
public class ThreadMutexByThreeThread {  

 public static void main(String[] args) {  

 final   Buiness2 b = new Buiness2();  

  new Thread(){
   @Override
   public void run() {
    for (int i = 1; i <= 50; i++) {
      b.sub1();
    }
   }
  }.start();  

  new Thread(){
   @Override
   public void run() {
    for (int i = 1; i <= 50; i++) {
      b.sub2();
    }
   }
  }.start();  

  for (int i = 1; i <= 50; i++) {
    b.main();
  }
 }  

}  

class Buiness2{  

 /**
  *
  * 1 main  走
  * 2 sub1  走
  * 3 sub2 走
  *
  */
 private int shouldWho = 0;  

 private Lock lock = new ReentrantLock();  

 private  Condition con1 = lock.newCondition();
 private  Condition con2 = lock.newCondition();
 private  Condition con3 = lock.newCondition();  

 public  void sub1(){  

  lock.lock();
  try {
   while(shouldWho !=1 ){
    try {  

     // this.wait();
     con2.await();  

    } catch (Exception e) {
     e.printStackTrace();
    }
   }
   for (int j = 1; j <= 2; j++) {
    System.out.println("sub1 Thread  sequnced:"+j);
   }
   shouldWho = 2;
   con3.signal();
  } catch (Exception e) {
   e.printStackTrace();
  } finally{
   lock.unlock();
  }
 }  

 public  void sub2(){  

  lock.lock();
  try {
   while( shouldWho != 2  ){
    try {  

     // this.wait();
     con3.await();  

    } catch (Exception e) {
     e.printStackTrace();
    }
   }
   for (int j = 1; j <= 2; j++) {
    System.out.println("sub2 Thread  sequnced:"+j);
   }
   shouldWho = 0;
   con1.signal();
  } catch (Exception e) {
   e.printStackTrace();
  } finally{
   lock.unlock();
  }  

 }  

 public   void main(){
  lock.lock();
  try {
   while( shouldWho != 0 ){
    try {
     con1.await();
    } catch (Exception e) {
     e.printStackTrace();
    }
   }  

   for (int j = 1; j <= 1; j++) {
    System.out.println("main Thread  sequnced:"+j);
   }  

   shouldWho = 1;
   //this.notify();
   con2.signal();
  } catch (Exception e) {
   e.printStackTrace();
  } finally{
   lock.unlock();
  }  

 }
}