用Lock对象来同步线程，实现生产者消费者模式

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


public class DeadLock {
	public static void main(String[] args) {
		Account ac = new Account(4, "qhairen");
		new Thread(new Drawer(ac)).start();
		
		new Thread(new Depositer(ac)).start();
		new Thread(new Depositer(ac)).start();
		new Thread(new Depositer(ac)).start();
	}
}

class Account {
	private String name;
	private int total;
	private Lock lock = new ReentrantLock();
	public Account(int total, String name) {
		this.total = total;
		this.name = name;
	}
	public void draw() {
		lock.lock();
		try{
			while(total <= 0) {
				lock.unlock();
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				lock.lock();
			}
			--total;
			System.out.println(name + " draw, now $" + total);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} finally {
			lock.unlock();
		}
	}
	public void deposit() {
		lock.lock();
		try {
			while(total >= 5) {
				lock.unlock();
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				lock.lock();
			}
			++total;
			System.out.println(name + " deposit, now $" + total);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} finally {
			lock.unlock();
		}
		
	}
}

class Drawer implements Runnable {
	private Account ac;
	public Drawer(Account ac){
		this.ac = ac;
	}
	public void run() {
		while(true) {
			ac.draw();
		}
	}
}

class Depositer implements Runnable{
	private Account ac;
	public Depositer(Account ac){
		this.ac = ac;
	}
	public void run() {
		while(true) {
			ac.deposit();
		}
	}
}

简述synchronized和java.util.concurrent.locks.Lock的异同 ？ 

主要相同点：Lock能完成synchronized所实现的所有功能 

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。 

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

private Lock lock = new ReentrantLock();

lock.lock();

try{

  .......

} finally{

     lock.unlock();

}

ps：unlock()最好放在函数的最后，不然其他线程会得到锁，就可能不执行该线程剩下的代码了。