锁对象-条件对象-synchronized关键字

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

public class BankCondition {
    public BankCondition(int n,double initialBalance){
        accounts = new double[n];
        for(int i=0;i<accounts.length;i++)
            accounts[i]=initialBalance;
        bankLock =new ReentrantLock();
        
    }
    public  void transfer(int from,int to,double amount)throws InterruptedException
    {
        bankLock.lock();
        try{
            while(accounts[from]<amount)
                sufficientFunds.await();
            System.out.print(Thread.currentThread());
            
            accounts[from]-= amount;
            System.out.printf("%10.2f from %d to %d",amount,from,to);
            accounts[to]+=amount;
            System.out.printf("Total Balance: %10.2f%n",getTotalBalance());
            sufficientFunds.signalAll();
        }
        finally
        {
            bankLock.unlock();
        }
    }
    public  double getTotalBalance()
    {
        bankLock.lock();
        try{
            double sum = 0;
            for(double a : accounts)
                sum +=a;
            return sum;
        }
        finally
        {
            bankLock.unlock();
        }
    }
    public int size(){
        return accounts.length;
    }
    
    
    private final double [] accounts;
    private Lock bankLock;
    private Condition sufficientFunds;
}

　　锁用来保护代码片段，任何时刻只有一个线程执行被保护的对象；

　　锁可以管理试图进入被保护代码段的线程；

　　锁可以拥有一个或多个相关的条件对象；

　　每个条件对象管理那些已经进入被保护代码段但还不能运行的线程。

Java中的对象都有一个内部锁，如果一个方法用synchronized关键字声明，那么对象的锁将保护整个方法。也就是说，要调用该方法，线程必须获得内部的对象锁。

public synchronized void method()
{
    method body;
}
等价于：
public void method(){
    this.intrinsicLock.lock();
    try
    {
        method body;
    }
    finally
    {
        this.intrinsicLock.unlock();
    }