1 /*
   2  * Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package nsk.share.locks;
  24 
  25 import java.util.*;
  26 import java.util.concurrent.locks.ReentrantLock;
  27 
  28 import nsk.share.Consts;
  29 import nsk.share.Log;
  30 import nsk.share.TestBug;
  31 import nsk.share.TestJNIError;
  32 import nsk.share.Wicket;
  33 
  34 /*
  35  Thread with possibility acquiring monitors in different ways:
  36  - entering synchronized method
  37  - entering synchronized method for thread object itself
  38  - entering synchronized static method
  39  - entering synchronized method for thread class itself
  40  - entering synchronized block on non-static object
  41  - entering synchronized block on non-static on thread object itself
  42  - entering synchronized block on static object
  43  - entering synchronized block on static thread object itself
  44  - JNI MonitorEnter.
  45 
  46  Description of required thread stack should be passed to LockingThread in constructor.
  47  When started locking thread create required stack and sleep until not interrupted.
  48 
  49  LockingThread can relinquish acquired monitors in follows ways:
  50  - relinquish single monitor through Object.wait - relinquishMonitor(int monitorIndex),
  51  - relinquish single monitor through exiting from synchronized blocks/methods or through JNI MonitorExit  - exitSingleFrame(),
  52  - relinquish all monitors(exit from all synchronized blocks/methods) - stopLockingThread()
  53 
  54  Debug information about each acquired/relinquished monitor is stored and can be obtained through getMonitorsInfo().
  55 
  56  To be sure that LockingThread have reached required state call method LockingThread.waitState().
  57 
  58  Usage example:
  59 
  60  List<String> stackFramesDescription = new ArrayList<String>();
  61  stackFramesDescription.add(LockingThread.SYNCHRONIZED_METHOD);
  62  stackFramesDescription.add(LockingThread.SYNCHRONIZED_OBJECT_BLOCK);
  63 
  64  LockingThread lockingThread = new LockingThread(log, stackFramesDescription);
  65 
  66  lockingThread.start();
  67 
  68  // after calling waitState() LockingThread should complete stack creation
  69   lockingThread.waitState();
  70 
  71   lockingThread.exitSingleFrame();
  72 
  73   // after calling waitState() LockingThread should complete exit from stack frame
  74    lockingThread.waitState();
  75    */
  76 public class LockingThread extends Thread {
  77     // native part uses TestJNIError class
  78     private static final Class<?> jniErrorKlass = TestJNIError.class;
  79     static {
  80         try {
  81             System.loadLibrary("LockingThread");
  82         } catch (UnsatisfiedLinkError e) {
  83             System.out.println("Unexpected UnsatisfiedLinkError on loading library 'LockingThread'");
  84             e.printStackTrace(System.out);
  85             System.exit(Consts.JCK_STATUS_BASE + Consts.TEST_FAILED);
  86         }
  87     }
  88 
  89     /*
  90      *  Information about acquired monitor
  91      */
  92     public static class DebugMonitorInfo {
  93         public DebugMonitorInfo(Object monitor, int stackDepth, Thread thread, boolean isNative) {
  94             this.monitor = monitor;
  95             this.stackDepth = stackDepth;
  96             this.thread = thread;
  97             this.isNative = isNative;
  98         }
  99 
 100         public Object monitor;
 101 
 102         public int stackDepth;
 103 
 104         public Thread thread;
 105 
 106         boolean isNative;
 107     }
 108 
 109     // acquire JNI monitor through JNIMonitorEnter()
 110     public static final String JNI_MONITOR_ENTER = "JNI_MONITOR_ENTER";
 111 
 112     // entering synchronized static method
 113     public static final String SYNCHRONIZED_STATIC_METHOD = "SYNCHRONIZED_STATIC_METHOD";
 114 
 115     // entering synchronized static method for thread class itself
 116     public static final String SYNCHRONIZED_STATIC_THREAD_METHOD = "SYNCHRONIZED_STATIC_THREAD_METHOD";
 117 
 118     // entering synchronized method
 119     public static final String SYNCHRONIZED_METHOD = "SYNCHRONIZED_METHOD";
 120 
 121     // entering synchronized method for thread object itself
 122     public static final String SYNCHRONIZED_THREAD_METHOD = "SYNCHRONIZED_THREAD_METHOD";
 123 
 124     // entering synchronized block for thread object itself
 125     public static final String SYNCHRONIZED_THIS_BLOCK = "SYNCHRONIZED_THIS_BLOCK";
 126 
 127     // entering synchronized block
 128     public static final String SYNCHRONIZED_OBJECT_BLOCK = "SYNCHRONIZED_OBJECT_BLOCK";
 129 
 130     // entering synchronized block on static object
 131     public static final String SYNCHRONIZED_BLOCK_STATIC_OBJECT = "SYNCHRONIZED_BLOCK_STATIC_OBJECT";
 132 
 133     // entering synchronized block on static thread object itself
 134     public static final String SYNCHRONIZED_BLOCK_STATIC_THREAD_OBJECT = "SYNCHRONIZED_BLOCK_STATIC_THREAD_OBJECT";
 135 
 136     // entering frame without monitor acquiring
 137     public static final String FRAME_WITHOUT_LOCK = "FRAME_WITHOUT_LOCK";
 138 
 139     // all acquired monitors
 140     private List<DebugMonitorInfo> monitorsInfo = new ArrayList<DebugMonitorInfo>();
 141 
 142     // This parameter should be passed in constructor
 143     // It describe how many locks and in which way LockingThread should acquire
 144     private List<String> stackFramesDescription;
 145 
 146     private Log log;
 147 
 148     // is during LockingThread's operations any errors occurred
 149     private boolean executedWithErrors;
 150 
 151     public boolean isExecutedWithErrors() {
 152         return executedWithErrors;
 153     }
 154 
 155     public LockingThread(Log log, List<String> stackFramesDescription) {
 156         this.log = log;
 157         this.stackFramesDescription = stackFramesDescription;
 158     }
 159 
 160     // return array containing all acquired monitors
 161     public DebugMonitorInfo[] getMonitorsInfo(boolean returnJNIMonitors) {
 162         Map<Object, DebugMonitorInfo> result = new HashMap<Object, DebugMonitorInfo>();
 163 
 164         for (int i = monitorsInfo.size() - 1; i >= 0; i--) {
 165             DebugMonitorInfo monitorInfo = monitorsInfo.get(i);
 166 
 167             if ((returnJNIMonitors || !monitorInfo.isNative) &&
 168 
 169             // don't return relinquished monitors
 170                     (monitorInfo.monitor != relinquishedMonitor) &&
 171 
 172                     // return only last monitor occurrence
 173                     !result.containsKey(monitorInfo.monitor)) {
 174                 result.put(monitorInfo.monitor, monitorInfo);
 175             }
 176         }
 177 
 178         return result.values().toArray(new DebugMonitorInfo[] {});
 179     }
 180 
 181     void log(String message) {
 182         log.display(Thread.currentThread().getName() + ": " + message);
 183     }
 184 
 185     // add debug information about acquired monitor
 186     void addMonitorInfo(DebugMonitorInfo monitorInfo) {
 187         monitorsInfo.add(monitorInfo);
 188     }
 189 
 190     // remove debug information about acquired monitor (also should update information about stack depth)
 191     void removeMonitorInfo(DebugMonitorInfo removedMonitor) {
 192         for (DebugMonitorInfo monitor : monitorsInfo) {
 193             if (monitor.stackDepth > removedMonitor.stackDepth)
 194                 monitor.stackDepth -= 2;
 195         }
 196 
 197         monitorsInfo.remove(removedMonitor);
 198     }
 199 
 200     // used for stack frames creation
 201     private int currentIndex;
 202 
 203     // Recursive function used for stack frames creation
 204 
 205     // For example if LockingThread should acquire 1 monitor through synchronized block
 206     // and 1 monitor through synchronized method pass list with values SYNCHRONIZED_METHOD and SYNCHRONIZED_OBJECT_BLOCK
 207     // to the constructor and after running LockingThread will have following stack frames:
 208 
 209     // run()
 210     //  createStackFrame()
 211     //      ClassWithSynchronizedMethods().synchronizedMethod() // monitor for instance of ClassWithSynchronizedMethods is acquired here
 212     //          createStackFrame()
 213     //              synchronizedObjectBlock()   // monitor for instance of Object is acquired here
 214     //                  createStackFrame()
 215     //                      doWait()
 216     //                          sleep()
 217 
 218     // When LockingThread have created required stack frame it calls method doWait() and sleep(Long.MAX_VALUE)
 219 
 220     // If LockingThread should relinquish one of the acquired monitors it should be interrupted and after
 221     // interrupting should call 'wait()' for specified monitor, and for this example LockingThread will have
 222     // following stack frames:
 223 
 224     // run()
 225     //  createStackFrame()
 226     //      ClassWithSynchronizedMethods().synchronizedMethod() // monitor for instance of ClassWithSynchronizedMethods is acquired here
 227     //          createStackFrame()
 228     //              synchronizedObjectBlock()   // monitor for instance of Object is acquired here
 229     //                  createStackFrame()
 230     //                      doWait()
 231     //                          relinquishedMonitor.wait()
 232 
 233     // LockingThread still holds all other locks because of it didn't exit from corresponding synchronized methods and blocks.
 234     // To let LockingThread acquire relinquished monitor 'relinquishedMonitor.notifyAll()' should be called, after this
 235     // LockingThread will acquire this monitor again because of it still in corresponding synchronized method or block and
 236     // it will have again such stack frames:
 237 
 238     // run()
 239     //  createStackFrame()
 240     //      ClassWithSynchronizedMethods().synchronizedMethod() // monitor for instance of ClassWithSynchronizedMethods is acquired here
 241     //          createStackFrame()
 242     //              synchronizedObjectBlock()   // monitor for instance of Object is acquired here
 243     //                  createStackFrame()
 244     //                      doWait()
 245     //                          sleep()
 246     void createStackFrame() {
 247         if (currentIndex < stackFramesDescription.size()) {
 248             String frameDescription = stackFramesDescription.get(currentIndex);
 249 
 250             currentIndex++;
 251 
 252             if (frameDescription.equals(JNI_MONITOR_ENTER)) {
 253                 // for JNI monitors -1 is returned as stack depth
 254                 int currentStackDepth = -1;
 255                 Object object = new Object();
 256                 DebugMonitorInfo monitorInfo = new DebugMonitorInfo(object, currentStackDepth, this, true);
 257                 addMonitorInfo(monitorInfo);
 258                 log("Enter JNI monitor");
 259                 nativeJNIMonitorEnter(object);
 260                 log("Exit JNI monitor");
 261                 removeMonitorInfo(monitorInfo);
 262             } else if (frameDescription.equals(SYNCHRONIZED_BLOCK_STATIC_OBJECT)) {
 263                 synchronizedBlockStaticObject();
 264             } else if (frameDescription.equals(SYNCHRONIZED_BLOCK_STATIC_THREAD_OBJECT)) {
 265                 synchronizedBlockStaticThreadObject();
 266             } else if (frameDescription.equals(SYNCHRONIZED_METHOD)) {
 267                 new ClassWithSynchronizedMethods().synchronizedMethod(this);
 268             } else if (frameDescription.equals(SYNCHRONIZED_THREAD_METHOD)) {
 269                 synchronizedMethod();
 270             } else if (frameDescription.equals(SYNCHRONIZED_STATIC_METHOD)) {
 271                 ClassWithSynchronizedMethods.synchronizedStaticMethod(this);
 272             } else if (frameDescription.equals(SYNCHRONIZED_STATIC_THREAD_METHOD)) {
 273                 synchronizedStaticMethod(this);
 274             } else if (frameDescription.equals(SYNCHRONIZED_THIS_BLOCK)) {
 275                 synchronizedThisBlock();
 276             } else if (frameDescription.equals(SYNCHRONIZED_OBJECT_BLOCK)) {
 277                 synchronizedObjectBlock();
 278             } else if (frameDescription.equals(FRAME_WITHOUT_LOCK)) {
 279                 frameWithoutLock();
 280             } else
 281                 throw new TestBug("Invalid stack frame description: " + frameDescription);
 282         } else {
 283             // required stack is created
 284             ready();
 285             doWait();
 286         }
 287 
 288         if (exitSingleFrame) {
 289             if (currentIndex-- < stackFramesDescription.size()) {
 290                 // exit from single synchronized block/method
 291                 ready();
 292                 doWait();
 293             }
 294         }
 295     }
 296 
 297     public Object getRelinquishedMonitor() {
 298         return relinquishedMonitor;
 299     }
 300 
 301     private Object relinquishedMonitor;
 302 
 303     private Wicket waitStateWicket = new Wicket();
 304 
 305     private Thread.State requiredState;
 306 
 307     public void waitState() {
 308         // try wait with timeout to avoid possible hanging (if LockingThread have finished execution because of uncaught exception)
 309         int result = waitStateWicket.waitFor(60000);
 310 
 311         if (result != 0) {
 312             throw new TestBug("Locking thread can't reach required state (waitStateWicket wasn't unlocked)");
 313         }
 314 
 315         if (requiredState == null)
 316             throw new TestBug("Required state not specified");
 317 
 318         long startTime = System.currentTimeMillis();
 319 
 320         // additional check to be sure that LockingThread acquired state
 321         while (this.getState() != requiredState) {
 322 
 323             // try wait with timeout to avoid possible hanging if something will go wrong
 324             if ((System.currentTimeMillis() - startTime) > 60000) {
 325                 throw new TestBug("Locking thread can't reach required state (state: " + requiredState + " wasn't reached) in 1 minute");
 326             }
 327 
 328             yield();
 329         }
 330 
 331         requiredState = null;
 332 
 333         Object relinquishedMonitor = getRelinquishedMonitor();
 334         /*
 335          * Changing thread state and release of lock is not single/atomic operation.
 336          * As result there is a potential race when thread state (LockingThread) has
 337          * been changed but the lock has not been released yet. To avoid this current
 338          * thread is trying to acquire the same monitor, so current thread proceeds
 339          * execution only when monitor has been really relinquished by LockingThread.
 340          */
 341         if (relinquishedMonitor != null) {
 342             synchronized (relinquishedMonitor) {
 343             }
 344         }
 345     }
 346 
 347     // LockingThread acquired required state
 348     private void ready() {
 349         waitStateWicket.unlockAll();
 350     }
 351 
 352     // is LockingThread should relinquish single monitor
 353     private volatile boolean relinquishMonitor;
 354 
 355     private int relinquishedMonitorIndex;
 356 
 357     // relinquish single monitor with given index through Object.wait()
 358     public void relinquishMonitor(int index) {
 359         if (index >= monitorsInfo.size()) {
 360             throw new TestBug("Invalid monitor index: " + index);
 361         }
 362 
 363         requiredState = Thread.State.WAITING;
 364         waitStateWicket = new Wicket();
 365         relinquishMonitor = true;
 366         relinquishedMonitorIndex = index;
 367 
 368         interrupt();
 369 
 370         DebugMonitorInfo monitorInfo = monitorsInfo.get(relinquishedMonitorIndex);
 371 
 372         if (monitorInfo == null)
 373             throw new TestBug("Invalid monitor index: " + relinquishedMonitorIndex);
 374     }
 375 
 376     public void acquireRelinquishedMonitor() {
 377         if (relinquishedMonitor == null) {
 378             throw new TestBug("There is no relinquished monitor");
 379         }
 380 
 381         // Set requiredState to 'Thread.State.TIMED_WAITING' because of LockingThread call
 382         // Thread.sleep(Long.MAX_VALUE) after monitor acquiring
 383         requiredState = Thread.State.TIMED_WAITING;
 384 
 385         waitStateWicket = new Wicket();
 386         relinquishMonitor = false;
 387 
 388         synchronized (relinquishedMonitor) {
 389             relinquishedMonitor.notifyAll();
 390         }
 391     }
 392 
 393     public void stopLockingThread() {
 394         requiredState = Thread.State.TIMED_WAITING;
 395 
 396         waitStateWicket = new Wicket();
 397         exitSingleFrame = false;
 398 
 399         interrupt();
 400     }
 401 
 402     // is thread should exit from single synchronized block/method
 403     private boolean exitSingleFrame;
 404 
 405     public void exitSingleFrame() {
 406         requiredState = Thread.State.TIMED_WAITING;
 407 
 408         waitStateWicket = new Wicket();
 409         exitSingleFrame = true;
 410 
 411         interrupt();
 412     }
 413 
 414     // LockingThread call this method when required state is reached
 415     private void doWait() {
 416         while (true) {
 417             try {
 418                 Thread.sleep(Long.MAX_VALUE);
 419             } catch (InterruptedException e) {
 420                 // expected exception, LockingThread should be interrupted to change state
 421             }
 422 
 423             // if single monitor should be relinquished through Object.wait()
 424             if (relinquishMonitor) {
 425                 try {
 426                     DebugMonitorInfo monitorInfo = monitorsInfo.get(relinquishedMonitorIndex);
 427 
 428                     if (monitorInfo == null)
 429                         throw new TestBug("Invalid monitor index: " + relinquishedMonitorIndex);
 430 
 431                     relinquishedMonitor = monitorInfo.monitor;
 432 
 433                     log("Relinquish monitor: " + relinquishedMonitor);
 434 
 435                     // monitor is relinquished
 436                     ready();
 437 
 438                     // Really monitor is relinquished only when LockingThread calls relinquishedMonitor.wait(0) below,
 439                     // but to be sure that LockingThread have reached required state method waitState() should be called
 440                     // and this method waits when LockingThred change state to 'Thread.State.WAITING'
 441 
 442                     while (relinquishMonitor)
 443                         relinquishedMonitor.wait(0);
 444 
 445                     log("Acquire relinquished monitor: " + relinquishedMonitor);
 446                 } catch (Exception e) {
 447                     executedWithErrors = true;
 448                     log("Unexpected exception: " + e);
 449                     e.printStackTrace(log.getOutStream());
 450                 }
 451 
 452                 relinquishedMonitor = null;
 453 
 454                 // monitor is acquired again
 455                 //(becuase we still are located in the frame where lock was acquired before we relinquished it)
 456                 ready();
 457             } else
 458                 // exit from frame
 459                 break;
 460         }
 461     }
 462 
 463     public void run() {
 464         // LockingThread call Thread.sleep() when required stack frame was created
 465         requiredState = Thread.State.TIMED_WAITING;
 466 
 467         createStackFrame();
 468 
 469         // thread relinquished all monitors
 470         ready();
 471         doWait();
 472     }
 473 
 474     static synchronized void synchronizedStaticMethod(LockingThread lockingThread) {
 475         int currentStackDepth = lockingThread.expectedDepth();
 476 
 477         lockingThread.log("Enter synchronized static thread method");
 478 
 479         DebugMonitorInfo monitorInfo = new DebugMonitorInfo(LockingThread.class, currentStackDepth, lockingThread, false);
 480         lockingThread.addMonitorInfo(monitorInfo);
 481         lockingThread.createStackFrame();
 482         lockingThread.removeMonitorInfo(monitorInfo);
 483 
 484         lockingThread.log("Exit synchronized static thread method");
 485     }
 486 
 487     // calculate stack depth at which monitor was acquired
 488     int expectedDepth() {
 489         // for each monitor call 2 methods: createStackFrame() and method which acquire monitor
 490         // + when stack creation is finished call 3 methods: createStackFrame()->doWait()->sleep()
 491         return (stackFramesDescription.size() - currentIndex) * 2 + 3;
 492     }
 493 
 494     private native void nativeJNIMonitorEnter(Object object);
 495 
 496     synchronized void synchronizedMethod() {
 497         int currentStackDepth = expectedDepth();
 498 
 499         log("Enter synchronized thread method");
 500 
 501         DebugMonitorInfo monitorInfo = new DebugMonitorInfo(this, currentStackDepth, this, false);
 502         addMonitorInfo(monitorInfo);
 503         createStackFrame();
 504         removeMonitorInfo(monitorInfo);
 505 
 506         log("Exit synchronized thread method");
 507     }
 508 
 509     void synchronizedThisBlock() {
 510         int currentStackDepth = expectedDepth();
 511 
 512         log("Enter synchronized(this) block");
 513 
 514         synchronized (this) {
 515             DebugMonitorInfo monitorInfo = new DebugMonitorInfo(this, currentStackDepth, this, false);
 516             addMonitorInfo(monitorInfo);
 517             createStackFrame();
 518             removeMonitorInfo(monitorInfo);
 519         }
 520 
 521         log("Exit synchronized(this) block");
 522     }
 523 
 524     private static Object staticObject;
 525 
 526     // 'staticObjectInitializingLock' is used in synchronizedBlockStaticObject() and synchronizedBlockStaticThreadObject().
 527     // In this methods LockingThread initializes static object and enters in synchronized block
 528     // for this static object, this actions are not thread safe(because of static fields are used) and 'staticObjectInitializingLock'
 529     // is used to prevent races
 530     private static ReentrantLock staticObjectInitializingLock = new ReentrantLock();
 531 
 532     void synchronizedBlockStaticObject() {
 533         int currentStackDepth = expectedDepth();
 534 
 535         // initializing of 'staticObject' and entering to the synchronized(staticObject) block should be thread safe
 536         staticObjectInitializingLock.lock();
 537 
 538         staticObject = new Object();
 539 
 540         log("Enter synchronized(static object) block");
 541 
 542         synchronized (staticObject) {
 543             // thread unsafe actions was done
 544             staticObjectInitializingLock.unlock();
 545 
 546             DebugMonitorInfo monitorInfo = new DebugMonitorInfo(staticObject, currentStackDepth, this, false);
 547             addMonitorInfo(monitorInfo);
 548             createStackFrame();
 549             removeMonitorInfo(monitorInfo);
 550         }
 551 
 552         log("Exit synchronized(static object) block");
 553     }
 554 
 555     private static LockingThread staticLockingThread;
 556 
 557     void synchronizedBlockStaticThreadObject() {
 558         int currentStackDepth = expectedDepth();
 559 
 560         // initializing of 'staticLockingThread' and entering to the synchronized(staticLockingThread) block should be thread safe
 561         staticObjectInitializingLock.lock();
 562 
 563         staticLockingThread = this;
 564 
 565         log("Enter synchronized(static thread object) block");
 566 
 567         synchronized (staticLockingThread) {
 568             // thread unsafe actions was done
 569             staticObjectInitializingLock.unlock();
 570 
 571             DebugMonitorInfo monitorInfo = new DebugMonitorInfo(staticLockingThread, currentStackDepth, this, false);
 572             addMonitorInfo(monitorInfo);
 573             createStackFrame();
 574             removeMonitorInfo(monitorInfo);
 575         }
 576 
 577         log("Exit synchronized(static thread object) block");
 578     }
 579 
 580     void synchronizedObjectBlock() {
 581         int currentStackDepth = expectedDepth();
 582 
 583         Object object = new Object();
 584 
 585         log("Enter synchronized(object) block");
 586 
 587         synchronized (object) {
 588             DebugMonitorInfo monitorInfo = new DebugMonitorInfo(object, currentStackDepth, this, false);
 589             addMonitorInfo(monitorInfo);
 590             createStackFrame();
 591             removeMonitorInfo(monitorInfo);
 592         }
 593 
 594         log("Exit synchronized(object) block");
 595     }
 596 
 597     private void frameWithoutLock() {
 598         log("Enter frameWithoutLock");
 599 
 600         createStackFrame();
 601 
 602         for (DebugMonitorInfo monitor : monitorsInfo)
 603             monitor.stackDepth -= 2;
 604 
 605         log("Exit frameWithoutLock");
 606     }
 607 }
 608 
 609 //class containing synchronized method and synchronized static method, used by LockingThread
 610 class ClassWithSynchronizedMethods {
 611     public synchronized void synchronizedMethod(LockingThread lockingThread) {
 612         int currentStackDepth = lockingThread.expectedDepth();
 613 
 614         lockingThread.log("Enter synchronized method");
 615 
 616         LockingThread.DebugMonitorInfo monitorInfo = new LockingThread.DebugMonitorInfo(this, currentStackDepth, lockingThread, false);
 617         lockingThread.addMonitorInfo(monitorInfo);
 618         lockingThread.createStackFrame();
 619         lockingThread.removeMonitorInfo(monitorInfo);
 620 
 621         lockingThread.log("Exit synchronized method");
 622     }
 623 
 624     public static synchronized void synchronizedStaticMethod(LockingThread lockingThread) {
 625         int currentStackDepth = lockingThread.expectedDepth();
 626 
 627         lockingThread.log("Enter synchronized static method");
 628 
 629         LockingThread.DebugMonitorInfo monitorInfo = new LockingThread.DebugMonitorInfo(ClassWithSynchronizedMethods.class, currentStackDepth,
 630                 lockingThread, false);
 631         lockingThread.addMonitorInfo(monitorInfo);
 632         lockingThread.createStackFrame();
 633         lockingThread.removeMonitorInfo(monitorInfo);
 634 
 635         lockingThread.log("Exit synchronized static method");
 636     }
 637 }