Java synchronized之“可重入锁”

概念

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

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

实例

package com.test.sync;

public class Main {
    public int i = 10;
    synchronized public void operateMainMethod(){
        try {
            i --;
            System.out.println("main print i = "+ i);
            Thread.sleep(1000);
        } catch (InterruptedException e) {

            e.printStackTrace();
        }
    }
}

package com.test.sync;

public class Sub extends Main{
    synchronized public void operateISubMethod(){
        try {
            while(i>0){
                i --;
                System.out.println("sub print i="+i);
                Thread.sleep(100);
                this.operateMainMethod();
            }
        } catch (InterruptedException e) {

            e.printStackTrace();
        }
    }
}

package com.test.sync;

public class MyThread extends Thread{
    @Override
    public void run() {

        Sub sub = new Sub();
        sub.operateISubMethod();
    }
}

package com.test.sync;

public class Test {

    public static void main(String[] args) {

        MyThread thread = new MyThread();
        thread.start();
    }

}

执行结果如下：

sub print i=9
main print i = 8
sub print i=7
main print i = 6
sub print i=5
main print i = 4
sub print i=3
main print i = 2
sub print i=1
main print i = 0

这说明，子类继承父类时，子类完全可以通过可重入锁调用父类的同步方法。