最简单的分析：可重入锁、不可重入锁、安全锁、非安全锁

可重入锁（递归锁）

         指的是：在调用含有锁的函数时，若相邻的调用都在同一个线程中，就不会阻塞，若相邻的调用不再同一个线程中，就会使其中一个线程执行阻塞等待操作。

            代码实例：

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函数都会被成功执行。

 

不可重入锁

         指的是：每次调用含有锁的函数时，若锁已被占用未释放，其他线程就阻塞等待。

         代码实例：

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

    }

}

  总结：print函数会被执行，doAdd()进入死锁状态，一直阻塞等待锁的释放。

 

安全锁（ReentrantLock(true)）

         指的是：在锁释放后，可以按照线程队列或者自定义的条件，唤醒指定的线程或者分组的线程们。

 

非安全锁（ReentrantLock(false)）

         指的是：与synchronize效果一样，在锁被释放后，线程们相互竞争来获取锁。