java并发编程实践学习（二）由可重入锁想到的
在《java并发编程实践》的第二章，介绍到了“可重入锁”的概念和作用，并且指出java的内置锁synchronized就是一种可重入锁。其中提到了Widget和LogginWidget，源码如下:
public class Widget {
public synchronized void doSomething() {
// do somethig here...
}
}
public class LoggingWidget extends Widget {
public synchronized void doSomething() {
System.out.println(toString() + ": calling doSomething");
super.doSomething();
}
}子类覆写了父类的synchonized方法，然后调用父类中的方法，此时如果没有重入的锁，那么这段代码将产生死锁。由于Widget 和LoggingWidget 中的doSomething方法都是synchonized方法，因此每个doSomething方法执行前都会获取Widget 上的锁。然而如果内置锁不是可重入的，那么在调用super.doSomething()时将无法获取Widget 上的锁，因为这个锁已经被持有，从而线程将永远停顿下去，等待一个永远也无法获得的锁。
看到红色部分的字体，想必大家会觉得疑惑。 线程进入LoggingWidget.doSomething()时获取的锁不应该是LoggingWidget对象锁吗?怎会是Widget上的锁?super.doSomething()获取的究竟是哪个对象锁呢？对于喜欢追究细节的我来说，此时有了种种疑问，尤其是写完第一篇博客： java并发编程实践学习（一）java的类锁和对象锁。按照字面的意思，貌似是说：执行子类对象的同步方法时候，也会获取父对象的锁，如果不是可重入锁的话，再次调用super.doSomething()想要第二次获取Widget对象的锁，就不会成功。
这里就产生了1个问题：什么是子类对象，什么是父类对象？是不是创建子类对象,肯定会创建一个父类的对象?
首先创建一个子类对象的时候是不会创建一个父类对象的，父类对象是根本不存在的。我们可以使用反证法，假如说创建子类对象的同时会创建一个父类对象，那如果父类是抽象类，不能实例化呢？我们知道使用A a = new A()这种方式创建对象的时候，JVM会在后台给我们分配内存空间，然后调用构造函数执行初始化操作，最后返回内存空间的引用。即构造函数只是进行初始化，并不负责分配内存空间（创建对象）。所以呢其实创建子类对象的时候，JVM会为子类对象分配内存空间，并调用父类的构造函数。我们可以这样理解：创建了一个子类对象的时候，在子类对象内存中，有两份数据，一份继承自父类，一份来自子类，但是他们属于同一个对象（子类对象），只不过是java语法提供了this和super关键字来让我们能够按照需要访问这2份数据而已。这样就产生了子类和父类的概念，但实际上只有子类对象，没有父类对象。
到这里，我们也就能够理解《java并发编程实践》中的话了。
LoggingWidget widget = new LoggingWidget();
widget.doSomengthing();由于doSomething()是synchronized方法，所以执行的时候，会先获取widget对象的锁；当执行到super.doSomething()的时候，由于父类中的方法也是synchronized方法，所以也必须先获取对象的锁。因为不存在所谓的父对象，或者说父对象就是子对象，所以需要获取的也是widget对象的锁。这样如果不是可重入的锁的话，就会产生死锁。
接下来我们就通过例子来证明：父类对象就是子类对象，即父类的synchronized方法和子类的synchronized方法属于同一个对象。
package net.aty.lock.extend;
public class BaseClass
{
public synchronized void doSomeThing()
{
System.out.println("parent class：begin.....doSomeThing");
try
{
Thread.sleep(200);
} catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("parent class：end.....doSomeThing");
}
}
package net.aty.lock.extend;
public class ChildClass extends BaseClass
{
public synchronized void childMethod()
{
System.out.println("---child class：begin.....childMethod");
try
{
Thread.sleep(200);
} catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("---child class：end.....childMethod");
}
}
package net.aty.lock.extend.thread;
import net.aty.lock.extend.BaseClass;
public class DemoThread1 extends Thread
{
private BaseClass base = null;
public DemoThread1(BaseClass base)
{
this.base = base;
}
@Override
public void run()
{
base.doSomeThing();
}
}package net.aty.lock.extend.thread;
import net.aty.lock.extend.ChildClass;
public class DemoThread2 extends Thread
{
private ChildClass child = null;
public DemoThread2(ChildClass child)
{
this.child = child;
}
@Override
public void run()
{
child.childMethod();
}
}
我的测试思路是：让一个线程去访问父类中的synchronized方法，然后再让另一个线程访问子类的synchronized方法。由于2个线程竞争的是同一个对象的锁，那么线程1不执行完毕，线程2是不会开始执行的。
package net.aty.lock.extend;
public class ChildClass extends BaseClass
{
public synchronized void childMethod()
{
System.out.println("---child class：begin.....childMethod");
try
{
Thread.sleep(200);
} catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("---child class：end.....childMethod");
}
}
执行结果是：
parent class：begin.....doSomeThing
...main running...
...main running...
parent class：end.....doSomeThing
---child class：begin.....childMethod
---child class：end.....childMethod
很显然程序符合了我们的预期，的确不存在父对象，访问父类的同步方法，跟访问子类的同步方法没有什么实质性的差别，都是要获取子类对象的锁。