Java多线程问题--synchronized锁重入

本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！

代码地址：https://github.com/xianzhixianzhixian/thread.git

关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象的锁时是可以再次得到该对象的锁的。这也证明在一个synchronized方法/块的内部调用本类的其它synchronized方法/块时，是永远可以得到锁的。

“可重入锁”的概念是：自己可以再次获得自己的内部锁。

“可重入锁”也支持在父子类继承的环境中，即当存在父子继承时，子类是完全可以通过“可重入锁”调用父类的同步方法的（这里自子类的方法为synchronized更易证明）。举例证明

Main.java

package thread.sync.lock.in;

/**
 * 测试在父子类继承中也支持可重入锁
 * @author: xianzhixianzhixian
 * @date: 2018-12-17 20:04
 */
public class Main {

    public int i = 10;

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

Sub.java

package thread.sync.lock.in;

/**
 * @author: xianzhixianzhixian
 * @date: 2018-12-17 20:07
 */
public class Sub extends Main {

    synchronized public void opreateISubMethod() {
        try {
            while (i>0){
                i--;
                System.out.println("sub print i="+i);
                Thread.sleep(100);
                this.opreateIMainMethod();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

MyThread.java

package thread.sync.lock.in;

/**
 * @author: xianzhixianzhixian
 * @date: 2018-12-17 20:09
 */
public class MyThread extends Thread {

    @Override
    public void run() {
        super.run();
        Sub sub = new Sub();
        sub.opreateISubMethod();
    }
}

Run.java

package thread.sync.lock.in;

/**
 * @author: xianzhixianzhixian
 * @date: 2018-12-17 20:10
 */
public class Run {

    public static void main(String[] args) {
        MyThread t= new MyThread();
        t.start();
    }
}

结果截图