ReenTrantLock与Condition

先上一段由传统的生产者 消费者模型改造的代码

class ReenTrantLockDemo{
	
	static ReentrantLock lock = new ReentrantLock();

	static Condition getLock = lock.newCondition();

	static Condition saveLock = lock.newCondition();

	static int money = 0;

	static void saveMoney(){

		while(true){
		    lock.lock();
		    try{
			for(int i=0;i<5;i++){
				money=money+100;
				System.out.println("存钱:"+money);
			}

			getLock.signal();

			saveLock.await();
                    }finally{
                        lock.unlock();
                    }
		}

	}


	static void getMoney(){
		
		while(true){
			lock.lock();

			getLock.await();

			money=money-500;

			System.out.println("取钱:"+money);

			saveLock.signal();
		}
		
	}

	public static void main(String args[]){

		new Thread(new Runnable(){
			public void run(){

				saveMoney();
			}
		}).start();

		new Thread(new Runnable(){
			public void run(){

				getMoney();
			}
		}).start();


	}

}

可见尽管synchronized在语法上已经足够简单了，在JDK 5之前只能借助此实现，

但是由于是独占锁，性能却不高，因此JDK 5以后就开始借助于JNI来完成更高级的锁实现。JDK 5中的锁是接口java.util.concurrent.locks.Lock 。

另外java.util.concurrent.locks.ReadWriteLock 提供了一对可供读写并发的锁。

根据前面的规则，我们从java.util.concurrent.locks.Lock 的API开始。

• void lock();
• 获取锁。如果锁不可用，出于线程调度目的，将禁用当前线程，并且在获得锁之前，该线程将一直处于休眠状态。

• void lockInterruptibly() throws InterruptedException;
• 如果当前线程未被中断，则获取锁。如果锁可用，则获取锁，并立即返回。如果锁不可用，出于线程调度目的，将禁用当前线程，并且在发生以下两种情况之一以前，该线程将一直处于休眠状态：锁由当前线程获得；或者其他某个线程中断 当前线程，并且支持对锁获取的中断。如果当前线程：在进入此方法时已经设置了该线程的中断状态；或者在获取锁时被中断 ，并且支持对锁获取的中断，则将抛出 InterruptedException ，并清除当前线程的已中断状态。

• Condition newCondition();返回绑定到此 Lock 实例的新 Condition 实例。