不可重入锁/自旋锁、可重入锁

转载自：http://blog.csdn.net/soonfly/article/details/70918802

锁分为可重入锁和不可重入锁。 
可重入和不可重入的概念是这样的：当一个线程获得了当前实例的锁，并进入方法A，这个线程在没有释放这把锁的时候，能否再次进入方法A呢？

• 可重入锁：可以再次进入方法A，就是说在释放锁前此线程可以再次进入方法A（方法A递归）。
• 不可重入锁（自旋锁）：不可以再次进入方法A，也就是说获得锁进入方法A是此线程在释放锁钱唯一的一次进入方法A。

先举例来说明锁的可重入性：

public class UnReentrant{    Lock lock = new Lock();    public void outer(){        lock.lock();        inner();        lock.unlock();    }    public void inner(){        lock.lock();        //do something        lock.unlock();    }}

outer中调用了inner，outer先锁住了lock，这样inner就不能再获取lock。其实调用outer的线程已经获取了lock锁，但是不能在inner中重复利用已经获取的锁资源，这种锁即称之为 不可重入 。通常也称为 自旋锁 。相对来说，可重入就意味着：线程可以进入任何一个它已经拥有的锁所同步着的代码块。

不可重入锁基本原理：

可以看到，当isLocked被设置为true后，在线程调用unlock()解锁之前不管线程是否已经获得锁，都只能wait()。 
代码如下：

public class Lock{      private boolean isLocked = false;      public synchronized void lock()          throws InterruptedException{          while(isLocked){              wait();          }          isLocked = true;      }      public synchronized void unlock(){          isLocked = false;          notify();      }  }  

可重入锁的基本原理

我们修改Lock，加入一个变量lockBy用来保存已经获得锁的线程，这样就能对有锁的线程放行。

public class Lock{    boolean isLocked = false;    Thread  lockedBy = null;    int lockedCount = 0;    public synchronized void lock() throws InterruptedException{        Thread callingThread = Thread.currentThread();        while(isLocked && lockedBy != callingThread){            wait();        }        isLocked = true;        lockedCount++;        lockedBy = callingThread;    }    public synchronized void unlock(){        if(Thread.curentThread() == this.lockedBy){            lockedCount--;            if(lockedCount == 0){                isLocked = false;                notify();            }        }    }}

解释一下程序中的两个变量： 
lockBy：保存已经获得锁实例的线程，在lock()判断调用lock的线程是否已经获得当前锁实例，如果已经获得锁，则直接跳过while，无需等待。 
lockCount：记录同一个线程重复对一个锁对象加锁的次数。否则，一次unlock就会解除所有锁，即使这个锁实例已经加锁多次了。

在java 中，synchronized和java.util.concurrent.locks.ReentrantLock是可重入锁。