概论

一个线程获取了某个对象的锁，那么它可以再次获得此对象的锁。这个锁就叫做可重入锁。

synchronized就是可重入锁，示例：

public class LeaningThread {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Test()).start();
    }
}
class Test implements Runnable{
    @Override
    public void run() {
        synchronized (this){//第一次获取到锁
            while (true){
                synchronized (this){
                    System.out.println("第二次获取到了this对象的锁");
                }
                try {
                    Thread.sleep(2000L);
                } catch (InterruptedException e) { e.printStackTrace();}
            }
        }
    }
}

运行结果：

原理

在锁内部加一个计数器，若是同一个对象来获取则给予锁，并计数器加一。

手动实现：

public class LeaningThread {
    //ReentrantLock myLock = new ReentrantLock();
    MyLock myLock = new MyLock();

    void doSomething1() throws InterruptedException {
        System.out.println("1获得锁："+myLock.getHoldCount());
        myLock.lock();
        System.out.println("2获得锁："+myLock.getHoldCount());
        doSomething2();
        myLock.unlock();
        System.out.println("5获得锁："+myLock.getHoldCount());
    }
    void doSomething2() throws InterruptedException {
        //再次获取锁
        myLock.lock();
        System.out.println("3获得锁："+myLock.getHoldCount());
        myLock.unlock();
        System.out.println("4获得锁："+myLock.getHoldCount());
    }

    public static void main(String[] args) throws InterruptedException {
        LeaningThread lt =new LeaningThread();
        lt.doSomething1();
    }
}

class MyLock{
    private boolean isLocked = false;//锁是否被占用
    Thread lockedBy=null;//被谁锁了
    private int holdCount=0;//计数器，第几次获得锁
    //使用锁
    public synchronized void lock() throws InterruptedException {
        Thread temp=Thread.currentThread();
        while(isLocked&&lockedBy!=temp){//锁被占用，且不是被当前线程占用的时候，进入等待
            wait();
        }
        //锁没有被占用，或者是同一个线程来获取，获得锁
        isLocked = true;
        //记下这个线程
        lockedBy=temp;
        //第几次获得锁
        holdCount++;
    }
    //释放锁
    public synchronized void unlock() throws InterruptedException {
        if(Thread.currentThread()==lockedBy){
            holdCount--;//计数器减一
            if(holdCount==0){//最外层锁释放了
                isLocked = false;
                notify();
                lockedBy=null;
            }
        }
    }

    /**
     * 获取现在的第几层锁
     * @return
     */
    public int getHoldCount() {
        return holdCount;
    }
}

运行结果：

总结：

可重入锁是指同一个线程可以多次获取同一个对象的锁。实现是在锁内部加一个计数器，若是同一个对象来获取则给与锁，并计数器加一。

JDK中已经实现的一个可重入锁:Java.util.concurrent.locks.ReentrantLock。