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

 1 import java.util.concurrent.locks.Condition;
 2 import java.util.concurrent.locks.Lock;
 3 import java.util.concurrent.locks.ReentrantLock;
 4
 5 public class BankCondition {
 6     public BankCondition(int n,double initialBalance){
 7         accounts = new double[n];
 8         for(int i=0;i<accounts.length;i++)
 9             accounts[i]=initialBalance;
10         bankLock =new ReentrantLock();
11
12     }
13     public  void transfer(int from,int to,double amount)throws InterruptedException
14     {
15         bankLock.lock();
16         try{
17             while(accounts[from]<amount)
18                 sufficientFunds.await();
19             System.out.print(Thread.currentThread());
20
21             accounts[from]-= amount;
22             System.out.printf("%10.2f from %d to %d",amount,from,to);
23             accounts[to]+=amount;
24             System.out.printf("Total Balance: %10.2f%n",getTotalBalance());
25             sufficientFunds.signalAll();
26         }
27         finally
28         {
29             bankLock.unlock();
30         }
31     }
32     public  double getTotalBalance()
33     {
34         bankLock.lock();
35         try{
36             double sum = 0;
37             for(double a : accounts)
38                 sum +=a;
39             return sum;
40         }
41         finally
42         {
43             bankLock.unlock();
44         }
45     }
46     public int size(){
47         return accounts.length;
48     }
49
50
51     private final double [] accounts;
52     private Lock bankLock;
53     private Condition sufficientFunds;
54 }

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

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

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

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

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

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