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

结果以下：

 结果说明：

当存在父子类进程关系时，子类时彻底能够经过"可重入锁"调用父类的同步方法的