synchronized的可重入锁

1. synchronized锁重入

锁重入的概念：在使用synchronized时，当一个线程得到一个对象锁后再次请求此对象锁时是可以得到该对象锁的。即在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以继续得到锁的(死递归会异常)。

class Service {

    synchronized public void service1(){
        System.out.println(Thread.currentThread().getName()+" -> service1.");
        service2();
    }
    synchronized public void service2(){
        System.out.println(Thread.currentThread().getName()+" -> service2.");
        service3();
    }
    synchronized public void service3(){
        System.out.println(Thread.currentThread().getName()+" -> service3.");
    }
}

class ServiceA extends Thread{
    private Service service;
    ServiceA(Service service,String name){
        super(name);
        this.service = service;
    }

    @Override
    public void run() {
        try{
            service.service1();
            Thread.sleep(2000);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

public class ServiceB extends Thread{
    private Service service;
    ServiceB(Service service,String name){
        super(name);
        this.service = service;
    }

    @Override
    public void run() {
        service.service1();
    }
}

public class Test {
    public static void main(String[] args) {
        Service s = new Service();
        ServiceA a = new ServiceA(s,"ThreadA");
        ServiceB b = new ServiceB(s,"ThreadB");

        a.start();
        b.start();
        /*
            可重入锁: 是指自己可以再次获取自己的内部锁；
            例如当A线程获取到同步锁时，可以再次获取该锁取访问其他方法。
            B线程和A线程共享实例化对象service必须同步执行。
         */
    }
}

2. 锁重入支持继承：锁重入也可以支持父子类继承的环境，子类在获得锁后完全可以通过锁重入调用父类的同步方法。

class Father {
    public int i = 10;
    synchronized public void FatherMethod(){
        try{
            i--;
            System.out.println(Thread.currentThread().getName() + " Father i = " + i);
            Thread.sleep(100);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}
class Son extends Father{
    synchronized public void SonMethod(){
        try{
            while(i > 0) {
                i--;
                System.out.println(Thread.currentThread().getName() + " Son i = " + i);
                Thread.sleep(100);
                super.FatherMethod();
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}
public class ThreadA implements Runnable{

    @Override
    public void run() {
        Son s = new Son();
        s.SonMethod();
    }
}