不可重入鎖也叫自旋鎖

　　指當一個方法呼叫了鎖之後，如持有本鎖的另一個方法也想執行，將會進入等待。那麼想要使用這個方法必須先釋放鎖方可呼叫

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();
    }
}

可重入鎖

　　指同一個執行緒裡，持有此鎖的兩個方法將均會執行，不需要先釋放，但是另一個持有此鎖的執行緒必須等待鎖釋放後才能使用

　　java裡，可重入鎖，如 synchronized

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

不可重入鎖例子的話，如下呼叫

public class Count{
    Lock lock = new Lock();
    public void print(){
        lock.lock();
        doAdd();
        lock.unlock();
    }
    public void doAdd(){
        lock.lock();
        //do something
        lock.unlock();
    }
}

當呼叫print的時候，由於獲得鎖，導致doAdd使用時陷入while迴圈而等待，所以需要先將鎖釋放後才可使用