java condition lock

package com.cn.whu;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadConditionLook {

	/**
	 * @param args
	 */
	//create a user's Account,watch out the "static"
	private static Account account = new Account();
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService executor = Executors.newFixedThreadPool(2);
		executor.execute(new DepositTask());
		executor.execute(new WithdrawTask());
		executor.shutdown();
		System.out.println("Thread 1\t\tThread 2\t\t\t\tBalance");
	}
	private static class Account{
		//create a new lock
		private static Lock lock = new ReentrantLock();
		//craete a condition
		private static Condition newDeposit = lock.newCondition();
		private int  balance =0;
		public int getBalance(){
			return balance;
		}
		public void withdraw(int mount){
			lock.lock();//Acqurie the lock
			try{
				while(balance<mount){
					System.out.println("\t\t\tWait for a deposit");
					newDeposit.await();
				}
				balance -=mount; 
				System.out.println("\t\t\tWithdraw "+mount+"\t\t\t\t\t"+getBalance());
			}catch(InterruptedException e){
				
			}finally{
				lock.unlock();
			}
		}
		public void depsoit(int mount){
			lock.lock();
			try{
				balance+=mount;
				System.out.println("Deposit "+mount+"\t\t\t\t\t\t\t\t"+getBalance());
				newDeposit.signalAll();
			}finally{
				lock.unlock();
			}
		}
	}
	//Task for deposit account;
	private static class DepositTask implements Runnable{

		@Override
		public void run() {
			// TODO Auto-generated method stub
			
			try{
				while(true){
					account.depsoit((int)(Math.random()*10)+1);
					Thread.sleep(1000);
				}
				
			}catch(InterruptedException e){
				
			}
			
			
		}
		
	}
	//Task for withdraw account
	private static class WithdrawTask implements Runnable{

		@Override
		public void run() {
			// TODO Auto-generated method stub
			try{
				while(true){
					account.withdraw((int)(Math.random()*10)+1);
					Thread.sleep(1000);
				}
			}catch(InterruptedException e){
				
			}
		}
		
	}
}

条件锁其实就是一个普通的锁加上了一个条件，如下面两行代码
//create a new lockprivate static Lock lock = new ReentrantLock();
//craete a conditionprivate static Condition newDeposit = lock.newCondition();
，重要的不是表象，是为什么需要这个条件锁，假设你有一个银行账户，密码你和你老婆都知道，你负责存钱，你老婆负责取钱，对存钱和取钱的代码都加了锁，所以是可以同步的。诶，平常存啊取的都挺好的，结果你俩矛盾了，你不去存钱，诶银行发现你老婆仍然可以取，而且透支了，你愿意不？银行愿意不？当然不愿意，也许你马上想到了，诶，我可以在取钱的时候加个条件去判断下，如果够取，那就让这个线程来取钱，否则呢？关键是这个否则呢？把这个线程干掉？不人道吧，让人家自己过N年后来取？这也不人道啊，评啥不是你通知人家老公存钱了，老婆过来看看，看够取不？诶，这个条件锁他就是这个为别人考虑的东西，你老婆一旦发现钱不够取了，他就打电话给你，嘿，小伙子，快点存钱，你说我有事，等会在存，等了很久，你存了一点，好，你在打电话给她，说，你可以去取取看，看过不，不够在打电话给我，够了直接取了就是