Synchronized可重入锁通俗易懂的简单分析

可重入锁概念：

当一个线程得到一个对象锁后，再次请求此对象时时可以再次得到该对象的锁的，这也证明synchronized方法/块的内部调用本类的其他synchronized方法/块时，时永远可以得到锁的。

public class Service {

    synchronized public void service1() {
        System.err.println("service1");
        service2();
    }

    synchronized public void service2() {
        System.err.println("service2");
        service3();
    }

    synchronized public void service3() {
        System.err.println("service3");

    }

}

public class SyncTest {
    public static void main(String[] args) {
        Service service = new Service();
        service.service1();
    }
}

输出结果如下：

运行结果说明：

自己可以再次获取自己的内部锁。比如有一条线程获得了某个对象多的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话就会造成死锁

可重入锁也支持父子类继承的环境中：

父类创建

public class Main {

    public int i = 10;

    public synchronized void operateMainMethon() {
        try {
            i--;
            System.err.println("main print i=" + i);
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

子类创建

public class Sub extends Main {

    public synchronized void operateSubMethon() {
        try {
            while (i > 0) {
                i--;
                System.err.println("sub print i=" + i);
                Thread.sleep(100);
                this.operateMainMethon();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果如下：

结果说明：

当存在父子类进程关系时，子类时完全可以通过"可重入锁"调用父类的同步方法的