Synchronized keyword was not supposed to be reentrant ?

Question

Synchronized block in the below code seems to be working properly as a reentrant code. I've written this to check out the reentrancy by causing a deadlock but it worked without deadlock./* This code might cause to a deadlock */
public class NotReentrant {
     public static void main(String[] args) {
          final LoggingWidget widget = new LoggingWidget();
          Thread t1 = new Thread(new Runnable() {
               public void run() { widget.execute(); }
          t1.start();
          try { t1.join(); } catch (Exception e) {}
          System.out.println("You might not going to see this: There is a deadlock !");
/* dummy classes that show the proof */
class Widget {
     public synchronized void execute() {
          System.out.println(toString() + " (base).execute: synchronized");
          synchronized (this) {
               System.out.println(toString() + " (base).execute: synchronized (this)");
               try { Thread.sleep(500); } catch (Exception e) {}
               System.out.println(toString() + " (base).execute");
               // .... code
class LoggingWidget extends Widget {
     public synchronized void execute() {
          System.out.println(toString() + ".execute: synchronized");
          super.execute();
          System.out.println(toString() + ".execute");
}

Answer 1

I perfectly understand how Java monitors work and I also perfectly know that Java synchronized ( aka intrinsic locks ) monitor is re-entrant.
The reason behind my previous post was that I am trying to check out a code which is written in Goetz's book: Java Concurreny in Practice. In there, he gives a code example that leads to a deadlock. Despite, I am aware of the fact that it cannot be occurred, I have given it a shot.
Thanks for the comments.