一篇文章让你彻底了解Java可重入锁和不可重入锁

public class ReentrantTest implements Runnable {
 
    @Override
    public void run() {
        get();
    }
 
    public synchronized void get() {
        System.out.println(Thread.currentThread().getName());
        set();
    }
 
    /**
     * 递归方法
     */
    public synchronized void set() {
        System.out.println(Thread.currentThread().getName());
    }
 
    /**
     * 这里的对象锁只有一个，就是rt对象的锁。
     * 当执行rt的get方法时，该线程获得rt对象的锁。在get方法内执行set方法时再次请求rt对象的锁，因为synchronized是可重入锁，所以又可以得到该锁。循环这个过程。
     * 假设不是可重入锁的话，那么请求的过程中会出现阻塞，从而导致死锁。
     * @param args
     */
    public static void main(String[] args) {
        ReentrantTest rt = new ReentrantTest();
        // for(;;)模拟无限循环
        for(;;){
            new Thread(rt).start();
        }
    }
}

public class Lock {
    private boolean isLocked = false;
    /**
     * 加锁
     */
    public synchronized void lock() throws Exception{
        while(isLocked){
            //当前线程释放锁，让出CPU，进入等待状态，直到被唤醒，才继续执行15行
            wait();
            System.out.println("wait");
        }
        isLocked = true;
    }
    /**
     * 解锁
     */
    public synchronized void unlock(){
        isLocked = false;
        //唤醒一个等待的线程继续执行
        notify();
    }
}

public class Test {
    Lock lock = new Lock();
    public void print() throws Exception{
        //加锁 标记为true
        lock.lock();
        //释放锁->等待 阻塞在16行
        doAdd();
        lock.unlock();
    }
    public void doAdd() throws Exception{
        lock.lock();
        System.out.println("doAdd");
        lock.unlock();
    }
 
    public static void main(String[] args)throws Exception {
        Test test=new Test();
        test.print();
    }
}