继承情境下的可重入锁

今天有个朋友在群里发了一个问题，《Java并发编程实战》这本书有一段话：由于Widget和LoggingWidget中的doSomething方法都是synchronized方法，因此每个doSomething方法在执行前都会获取Widget上的锁。然而如果内置锁不是可重入的，那么调用super.doSomething时将无法获得Widget上的锁，就会发生死锁。

主要有2两个问题：

1、每个doSomething()方法在执行前都会获取Widget上的锁，这里不应该一个是LoggingWidget对象的锁，一个是Widget对象的锁吗？

针对这个问题，咱们先来简单分析一下。

 

第一，super.doSomething()的调用者是谁。

答案是LoggingWidget对象。

咱们可以通过一个例子说明：

public class TestSuper {

    public static void main(String[] args) {

        LoggingWidget loggingWidget = new LoggingWidget();

        loggingWidget.doSomething();

    }

}

class Widget {

    public synchronized void doSomething() {

        System.out.println("Widget.doSomething(): " + this);

    }

}

class LoggingWidget extends Widget{

    @Override    

public synchronized void doSomething() {

        System.out.println("LoggingWidget.doSomething(): " + this);

        super.doSomething();

    }

}

如果执行这段代码，输出的都是子类LoggingWidget的实例。

 

第二，要理解本例中synchronized锁的是什么。

答案是锁的是对象。

如果这样理解起来还是比较抽象，咱们可以通过一个具体的例子来说明。

public class TestLock {

    public static void main(String[] args) {

        Student student = new Student();

        new Thread(() -> student.study()).start();

        new Thread(() -> student.rest()).start();

    }

}

class Student {

    public synchronized void study() {

        for (int i = 0; i < 1000; i++) {

            System.out.println("study");

            try {

                Thread.sleep(100);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public synchronized void rest() {

        for (int i = 0; i < 1000; i++) {

            System.out.println("rest");

            try {

                Thread.sleep(100);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

如果执行上面这段代码，会发现上面代码的study()和rest()会相互阻塞，因为两个synchronized代码块都是锁的student这个对象。

 

经过上两步的分析，咱们大致可以得出答案：

本例中的锁并不是“一个LoggingWidget对象的锁，一个是Widget对象的锁”，而都是LoggingWidget对象的锁，至于作者写成Widget对象的锁，个人认为是作者写的不严谨了。