Lock提供了一种无条件的，可轮询的，定时的，可中断的锁获取操作

轮询锁与定时锁

如果不能同时获取所需要的所有的锁，那么就可以使用可定时的或可轮询的锁获取方式来保证安全性。
如果得不到所有的锁，那么释放已经获得的所有的锁，并尝试重新获取锁。

  1. long endTime=now()+duration;
  2. Lock lock;
  4. while(true){
  5.     if(lock.lockA.tryLock){
  6.         try{// 如果请求不到所有的锁，释放已经有的锁
  7.             if(lock.lockB.tryLock){ 
  8.                 try{
  9.                     // dosomething();
  10.                     // return;
  11.                 }finally{
  12.                     lock.lockB.unlock();
  13.                 }
  14.             }
  15.         }finally{
  16.             lock.lockA.tryLock
  17.         }
  18.     }
  20.     if(endTime < now()) {  // 指定了时间的限制
  21.         return false;
  22.     }
  23.     // 睡一下，重新尝试获取锁
  24.     Thread.sleep(xxx);
  26. }

可中断的锁

使用Lock的**void **``lockInterruptibly() ``**throws **``InterruptedException;方法，
可以在获得锁的同时保持对中断的响应，被中断则抛出InterruptedException异常

  1. func() throw InterruptedException{
  2.     lock.lockInterruptibly();
  4.     try{
  5.         dosomething()
  6.     }finally{
  7.         lock.unlock();
  8.     }
  9. }

所有加锁、解锁都是显式的

  • 必须在finally中lock.unlock（）

使用它的理由：

  • 可以中断一个正在等待获取锁的线程
  • 取消一个等待锁时间过长的线程
  • 可以提供更灵活的加锁机制