public class Service {
    synchronized public void service1(){
        System.out.println("service1");
        service2();
    }

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

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

新建一個服務類：在這裡，沒一個方法都是加上了鎖的，”可重入鎖”的概念是，自己可以再次獲取自己的內部鎖。比如有1條執行緒獲得了 某個物件的鎖，此時這個物件鎖還沒有釋放，當其再次想要獲取這個物件的鎖的時候還是可以獲取的，如果不可以鎖重入的話，就會造成死鎖。

可重入鎖是支援在父子類種的繼承的。

在多執行緒裡面呼叫：

public class MyThread extends Thread {


    @Override
    public void run() {
        super.run();
        Service service = new Service();
        service.service1();
    }
}
 

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

service1
service2
service3

由此可以看出，就算是第一個方法沒有釋放掉鎖，第二個方法依然可以獲取鎖，並且執行。

“鎖重入”支援繼承

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

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.operateIMainMethod();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

在繼承種，鎖依然可重入。