638 lines
24 KiB
Java
638 lines
24 KiB
Java
/*
|
|
* Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
package nsk.share.locks;
|
|
|
|
import java.util.*;
|
|
import java.util.concurrent.locks.ReentrantLock;
|
|
|
|
import nsk.share.Consts;
|
|
import nsk.share.Log;
|
|
import nsk.share.TestBug;
|
|
import nsk.share.TestJNIError;
|
|
import nsk.share.Wicket;
|
|
|
|
/*
|
|
Thread with possibility acquiring monitors in different ways:
|
|
- entering synchronized method
|
|
- entering synchronized method for thread object itself
|
|
- entering synchronized static method
|
|
- entering synchronized method for thread class itself
|
|
- entering synchronized block on non-static object
|
|
- entering synchronized block on non-static on thread object itself
|
|
- entering synchronized block on static object
|
|
- entering synchronized block on static thread object itself
|
|
- JNI MonitorEnter.
|
|
|
|
Description of required thread stack should be passed to LockingThread in constructor.
|
|
When started locking thread create required stack and sleep until not interrupted.
|
|
|
|
LockingThread can relinquish acquired monitors in follows ways:
|
|
- relinquish single monitor through Object.wait - relinquishMonitor(int monitorIndex),
|
|
- relinquish single monitor through exiting from synchronized blocks/methods or through JNI MonitorExit - exitSingleFrame(),
|
|
- relinquish all monitors(exit from all synchronized blocks/methods) - stopLockingThread()
|
|
|
|
Debug information about each acquired/relinquished monitor is stored and can be obtained through getMonitorsInfo().
|
|
|
|
To be sure that LockingThread have reached required state call method LockingThread.waitState().
|
|
|
|
Usage example:
|
|
|
|
List<String> stackFramesDescription = new ArrayList<String>();
|
|
stackFramesDescription.add(LockingThread.SYNCHRONIZED_METHOD);
|
|
stackFramesDescription.add(LockingThread.SYNCHRONIZED_OBJECT_BLOCK);
|
|
|
|
LockingThread lockingThread = new LockingThread(log, stackFramesDescription);
|
|
|
|
lockingThread.start();
|
|
|
|
// after calling waitState() LockingThread should complete stack creation
|
|
lockingThread.waitState();
|
|
|
|
lockingThread.exitSingleFrame();
|
|
|
|
// after calling waitState() LockingThread should complete exit from stack frame
|
|
lockingThread.waitState();
|
|
*/
|
|
public class LockingThread extends Thread {
|
|
// native part uses TestJNIError class
|
|
private static final Class<?> jniErrorKlass = TestJNIError.class;
|
|
static {
|
|
try {
|
|
System.loadLibrary("LockingThread");
|
|
} catch (UnsatisfiedLinkError e) {
|
|
System.out.println("Unexpected UnsatisfiedLinkError on loading library 'LockingThread'");
|
|
e.printStackTrace(System.out);
|
|
System.exit(Consts.JCK_STATUS_BASE + Consts.TEST_FAILED);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Information about acquired monitor
|
|
*/
|
|
public static class DebugMonitorInfo {
|
|
public DebugMonitorInfo(Object monitor, int stackDepth, Thread thread, boolean isNative) {
|
|
this.monitor = monitor;
|
|
this.stackDepth = stackDepth;
|
|
this.thread = thread;
|
|
this.isNative = isNative;
|
|
}
|
|
|
|
public Object monitor;
|
|
|
|
public int stackDepth;
|
|
|
|
public Thread thread;
|
|
|
|
boolean isNative;
|
|
}
|
|
|
|
// acquire JNI monitor through JNIMonitorEnter()
|
|
public static final String JNI_MONITOR_ENTER = "JNI_MONITOR_ENTER";
|
|
|
|
// entering synchronized static method
|
|
public static final String SYNCHRONIZED_STATIC_METHOD = "SYNCHRONIZED_STATIC_METHOD";
|
|
|
|
// entering synchronized static method for thread class itself
|
|
public static final String SYNCHRONIZED_STATIC_THREAD_METHOD = "SYNCHRONIZED_STATIC_THREAD_METHOD";
|
|
|
|
// entering synchronized method
|
|
public static final String SYNCHRONIZED_METHOD = "SYNCHRONIZED_METHOD";
|
|
|
|
// entering synchronized method for thread object itself
|
|
public static final String SYNCHRONIZED_THREAD_METHOD = "SYNCHRONIZED_THREAD_METHOD";
|
|
|
|
// entering synchronized block for thread object itself
|
|
public static final String SYNCHRONIZED_THIS_BLOCK = "SYNCHRONIZED_THIS_BLOCK";
|
|
|
|
// entering synchronized block
|
|
public static final String SYNCHRONIZED_OBJECT_BLOCK = "SYNCHRONIZED_OBJECT_BLOCK";
|
|
|
|
// entering synchronized block on static object
|
|
public static final String SYNCHRONIZED_BLOCK_STATIC_OBJECT = "SYNCHRONIZED_BLOCK_STATIC_OBJECT";
|
|
|
|
// entering synchronized block on static thread object itself
|
|
public static final String SYNCHRONIZED_BLOCK_STATIC_THREAD_OBJECT = "SYNCHRONIZED_BLOCK_STATIC_THREAD_OBJECT";
|
|
|
|
// entering frame without monitor acquiring
|
|
public static final String FRAME_WITHOUT_LOCK = "FRAME_WITHOUT_LOCK";
|
|
|
|
// all acquired monitors
|
|
private List<DebugMonitorInfo> monitorsInfo = new ArrayList<DebugMonitorInfo>();
|
|
|
|
// This parameter should be passed in constructor
|
|
// It describe how many locks and in which way LockingThread should acquire
|
|
private List<String> stackFramesDescription;
|
|
|
|
private Log log;
|
|
|
|
// is during LockingThread's operations any errors occurred
|
|
private boolean executedWithErrors;
|
|
|
|
public boolean isExecutedWithErrors() {
|
|
return executedWithErrors;
|
|
}
|
|
|
|
public LockingThread(Log log, List<String> stackFramesDescription) {
|
|
this.log = log;
|
|
this.stackFramesDescription = stackFramesDescription;
|
|
}
|
|
|
|
// return array containing all acquired monitors
|
|
public DebugMonitorInfo[] getMonitorsInfo(boolean returnJNIMonitors) {
|
|
Map<Object, DebugMonitorInfo> result = new HashMap<Object, DebugMonitorInfo>();
|
|
|
|
for (int i = monitorsInfo.size() - 1; i >= 0; i--) {
|
|
DebugMonitorInfo monitorInfo = monitorsInfo.get(i);
|
|
|
|
if ((returnJNIMonitors || !monitorInfo.isNative) &&
|
|
|
|
// don't return relinquished monitors
|
|
(monitorInfo.monitor != relinquishedMonitor) &&
|
|
|
|
// return only last monitor occurrence
|
|
!result.containsKey(monitorInfo.monitor)) {
|
|
result.put(monitorInfo.monitor, monitorInfo);
|
|
}
|
|
}
|
|
|
|
return result.values().toArray(new DebugMonitorInfo[] {});
|
|
}
|
|
|
|
void log(String message) {
|
|
log.display(Thread.currentThread().getName() + ": " + message);
|
|
}
|
|
|
|
// add debug information about acquired monitor
|
|
void addMonitorInfo(DebugMonitorInfo monitorInfo) {
|
|
monitorsInfo.add(monitorInfo);
|
|
}
|
|
|
|
// remove debug information about acquired monitor (also should update information about stack depth)
|
|
void removeMonitorInfo(DebugMonitorInfo removedMonitor) {
|
|
for (DebugMonitorInfo monitor : monitorsInfo) {
|
|
if (monitor.stackDepth > removedMonitor.stackDepth)
|
|
monitor.stackDepth -= 2;
|
|
}
|
|
|
|
monitorsInfo.remove(removedMonitor);
|
|
}
|
|
|
|
// used for stack frames creation
|
|
private int currentIndex;
|
|
|
|
// Recursive function used for stack frames creation
|
|
|
|
// For example if LockingThread should acquire 1 monitor through synchronized block
|
|
// and 1 monitor through synchronized method pass list with values SYNCHRONIZED_METHOD and SYNCHRONIZED_OBJECT_BLOCK
|
|
// to the constructor and after running LockingThread will have following stack frames:
|
|
|
|
// run()
|
|
// createStackFrame()
|
|
// ClassWithSynchronizedMethods().synchronizedMethod() // monitor for instance of ClassWithSynchronizedMethods is acquired here
|
|
// createStackFrame()
|
|
// synchronizedObjectBlock() // monitor for instance of Object is acquired here
|
|
// createStackFrame()
|
|
// doWait()
|
|
// sleep()
|
|
|
|
// When LockingThread have created required stack frame it calls method doWait() and sleep(Long.MAX_VALUE)
|
|
|
|
// If LockingThread should relinquish one of the acquired monitors it should be interrupted and after
|
|
// interrupting should call 'wait()' for specified monitor, and for this example LockingThread will have
|
|
// following stack frames:
|
|
|
|
// run()
|
|
// createStackFrame()
|
|
// ClassWithSynchronizedMethods().synchronizedMethod() // monitor for instance of ClassWithSynchronizedMethods is acquired here
|
|
// createStackFrame()
|
|
// synchronizedObjectBlock() // monitor for instance of Object is acquired here
|
|
// createStackFrame()
|
|
// doWait()
|
|
// relinquishedMonitor.wait()
|
|
|
|
// LockingThread still holds all other locks because of it didn't exit from corresponding synchronized methods and blocks.
|
|
// To let LockingThread acquire relinquished monitor 'relinquishedMonitor.notifyAll()' should be called, after this
|
|
// LockingThread will acquire this monitor again because of it still in corresponding synchronized method or block and
|
|
// it will have again such stack frames:
|
|
|
|
// run()
|
|
// createStackFrame()
|
|
// ClassWithSynchronizedMethods().synchronizedMethod() // monitor for instance of ClassWithSynchronizedMethods is acquired here
|
|
// createStackFrame()
|
|
// synchronizedObjectBlock() // monitor for instance of Object is acquired here
|
|
// createStackFrame()
|
|
// doWait()
|
|
// sleep()
|
|
void createStackFrame() {
|
|
if (currentIndex < stackFramesDescription.size()) {
|
|
String frameDescription = stackFramesDescription.get(currentIndex);
|
|
|
|
currentIndex++;
|
|
|
|
if (frameDescription.equals(JNI_MONITOR_ENTER)) {
|
|
// for JNI monitors -1 is returned as stack depth
|
|
int currentStackDepth = -1;
|
|
Object object = new Object();
|
|
DebugMonitorInfo monitorInfo = new DebugMonitorInfo(object, currentStackDepth, this, true);
|
|
addMonitorInfo(monitorInfo);
|
|
log("Enter JNI monitor");
|
|
nativeJNIMonitorEnter(object);
|
|
log("Exit JNI monitor");
|
|
removeMonitorInfo(monitorInfo);
|
|
} else if (frameDescription.equals(SYNCHRONIZED_BLOCK_STATIC_OBJECT)) {
|
|
synchronizedBlockStaticObject();
|
|
} else if (frameDescription.equals(SYNCHRONIZED_BLOCK_STATIC_THREAD_OBJECT)) {
|
|
synchronizedBlockStaticThreadObject();
|
|
} else if (frameDescription.equals(SYNCHRONIZED_METHOD)) {
|
|
new ClassWithSynchronizedMethods().synchronizedMethod(this);
|
|
} else if (frameDescription.equals(SYNCHRONIZED_THREAD_METHOD)) {
|
|
synchronizedMethod();
|
|
} else if (frameDescription.equals(SYNCHRONIZED_STATIC_METHOD)) {
|
|
ClassWithSynchronizedMethods.synchronizedStaticMethod(this);
|
|
} else if (frameDescription.equals(SYNCHRONIZED_STATIC_THREAD_METHOD)) {
|
|
synchronizedStaticMethod(this);
|
|
} else if (frameDescription.equals(SYNCHRONIZED_THIS_BLOCK)) {
|
|
synchronizedThisBlock();
|
|
} else if (frameDescription.equals(SYNCHRONIZED_OBJECT_BLOCK)) {
|
|
synchronizedObjectBlock();
|
|
} else if (frameDescription.equals(FRAME_WITHOUT_LOCK)) {
|
|
frameWithoutLock();
|
|
} else
|
|
throw new TestBug("Invalid stack frame description: " + frameDescription);
|
|
} else {
|
|
// required stack is created
|
|
ready();
|
|
doWait();
|
|
}
|
|
|
|
if (exitSingleFrame) {
|
|
if (currentIndex-- < stackFramesDescription.size()) {
|
|
// exit from single synchronized block/method
|
|
ready();
|
|
doWait();
|
|
}
|
|
}
|
|
}
|
|
|
|
public Object getRelinquishedMonitor() {
|
|
return relinquishedMonitor;
|
|
}
|
|
|
|
private Object relinquishedMonitor;
|
|
|
|
private Wicket waitStateWicket = new Wicket();
|
|
|
|
private Thread.State requiredState;
|
|
|
|
public void waitState() {
|
|
// try wait with timeout to avoid possible hanging (if LockingThread have finished execution because of uncaught exception)
|
|
int result = waitStateWicket.waitFor(60000);
|
|
|
|
if (result != 0) {
|
|
throw new TestBug("Locking thread can't reach required state (waitStateWicket wasn't unlocked)");
|
|
}
|
|
|
|
if (requiredState == null)
|
|
throw new TestBug("Required state not specified");
|
|
|
|
long startTime = System.currentTimeMillis();
|
|
|
|
// additional check to be sure that LockingThread acquired state
|
|
while (this.getState() != requiredState) {
|
|
|
|
// try wait with timeout to avoid possible hanging if something will go wrong
|
|
if ((System.currentTimeMillis() - startTime) > 60000) {
|
|
throw new TestBug("Locking thread can't reach required state (state: " + requiredState + " wasn't reached) in 1 minute");
|
|
}
|
|
|
|
yield();
|
|
}
|
|
|
|
requiredState = null;
|
|
|
|
Object relinquishedMonitor = getRelinquishedMonitor();
|
|
/*
|
|
* Changing thread state and release of lock is not single/atomic operation.
|
|
* As result there is a potential race when thread state (LockingThread) has
|
|
* been changed but the lock has not been released yet. To avoid this current
|
|
* thread is trying to acquire the same monitor, so current thread proceeds
|
|
* execution only when monitor has been really relinquished by LockingThread.
|
|
*/
|
|
if (relinquishedMonitor != null) {
|
|
synchronized (relinquishedMonitor) {
|
|
}
|
|
}
|
|
}
|
|
|
|
// LockingThread acquired required state
|
|
private void ready() {
|
|
waitStateWicket.unlockAll();
|
|
}
|
|
|
|
// is LockingThread should relinquish single monitor
|
|
private volatile boolean relinquishMonitor;
|
|
|
|
private int relinquishedMonitorIndex;
|
|
|
|
// relinquish single monitor with given index through Object.wait()
|
|
public void relinquishMonitor(int index) {
|
|
if (index >= monitorsInfo.size()) {
|
|
throw new TestBug("Invalid monitor index: " + index);
|
|
}
|
|
|
|
requiredState = Thread.State.WAITING;
|
|
waitStateWicket = new Wicket();
|
|
relinquishMonitor = true;
|
|
relinquishedMonitorIndex = index;
|
|
|
|
interrupt();
|
|
|
|
DebugMonitorInfo monitorInfo = monitorsInfo.get(relinquishedMonitorIndex);
|
|
|
|
if (monitorInfo == null)
|
|
throw new TestBug("Invalid monitor index: " + relinquishedMonitorIndex);
|
|
}
|
|
|
|
public void acquireRelinquishedMonitor() {
|
|
if (relinquishedMonitor == null) {
|
|
throw new TestBug("There is no relinquished monitor");
|
|
}
|
|
|
|
// Set requiredState to 'Thread.State.TIMED_WAITING' because of LockingThread call
|
|
// Thread.sleep(Long.MAX_VALUE) after monitor acquiring
|
|
requiredState = Thread.State.TIMED_WAITING;
|
|
|
|
waitStateWicket = new Wicket();
|
|
relinquishMonitor = false;
|
|
|
|
synchronized (relinquishedMonitor) {
|
|
relinquishedMonitor.notifyAll();
|
|
}
|
|
}
|
|
|
|
public void stopLockingThread() {
|
|
requiredState = Thread.State.TIMED_WAITING;
|
|
|
|
waitStateWicket = new Wicket();
|
|
exitSingleFrame = false;
|
|
|
|
interrupt();
|
|
}
|
|
|
|
// is thread should exit from single synchronized block/method
|
|
private boolean exitSingleFrame;
|
|
|
|
public void exitSingleFrame() {
|
|
requiredState = Thread.State.TIMED_WAITING;
|
|
|
|
waitStateWicket = new Wicket();
|
|
exitSingleFrame = true;
|
|
|
|
interrupt();
|
|
}
|
|
|
|
// LockingThread call this method when required state is reached
|
|
private void doWait() {
|
|
while (true) {
|
|
try {
|
|
Thread.sleep(Long.MAX_VALUE);
|
|
} catch (InterruptedException e) {
|
|
// expected exception, LockingThread should be interrupted to change state
|
|
}
|
|
|
|
// if single monitor should be relinquished through Object.wait()
|
|
if (relinquishMonitor) {
|
|
try {
|
|
DebugMonitorInfo monitorInfo = monitorsInfo.get(relinquishedMonitorIndex);
|
|
|
|
if (monitorInfo == null)
|
|
throw new TestBug("Invalid monitor index: " + relinquishedMonitorIndex);
|
|
|
|
relinquishedMonitor = monitorInfo.monitor;
|
|
|
|
log("Relinquish monitor: " + relinquishedMonitor);
|
|
|
|
// monitor is relinquished
|
|
ready();
|
|
|
|
// Really monitor is relinquished only when LockingThread calls relinquishedMonitor.wait(0) below,
|
|
// but to be sure that LockingThread have reached required state method waitState() should be called
|
|
// and this method waits when LockingThred change state to 'Thread.State.WAITING'
|
|
|
|
while (relinquishMonitor)
|
|
relinquishedMonitor.wait(0);
|
|
|
|
log("Acquire relinquished monitor: " + relinquishedMonitor);
|
|
} catch (Exception e) {
|
|
executedWithErrors = true;
|
|
log("Unexpected exception: " + e);
|
|
e.printStackTrace(log.getOutStream());
|
|
}
|
|
|
|
relinquishedMonitor = null;
|
|
|
|
// monitor is acquired again
|
|
//(becuase we still are located in the frame where lock was acquired before we relinquished it)
|
|
ready();
|
|
} else
|
|
// exit from frame
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void run() {
|
|
// LockingThread call Thread.sleep() when required stack frame was created
|
|
requiredState = Thread.State.TIMED_WAITING;
|
|
|
|
createStackFrame();
|
|
|
|
// thread relinquished all monitors
|
|
ready();
|
|
doWait();
|
|
}
|
|
|
|
static synchronized void synchronizedStaticMethod(LockingThread lockingThread) {
|
|
int currentStackDepth = lockingThread.expectedDepth();
|
|
|
|
lockingThread.log("Enter synchronized static thread method");
|
|
|
|
DebugMonitorInfo monitorInfo = new DebugMonitorInfo(LockingThread.class, currentStackDepth, lockingThread, false);
|
|
lockingThread.addMonitorInfo(monitorInfo);
|
|
lockingThread.createStackFrame();
|
|
lockingThread.removeMonitorInfo(monitorInfo);
|
|
|
|
lockingThread.log("Exit synchronized static thread method");
|
|
}
|
|
|
|
// calculate stack depth at which monitor was acquired
|
|
int expectedDepth() {
|
|
// for each monitor call 2 methods: createStackFrame() and method which acquire monitor
|
|
// + when stack creation is finished call 3 methods: createStackFrame()->doWait()->sleep()
|
|
return (stackFramesDescription.size() - currentIndex) * 2 + 3;
|
|
}
|
|
|
|
private native void nativeJNIMonitorEnter(Object object);
|
|
|
|
synchronized void synchronizedMethod() {
|
|
int currentStackDepth = expectedDepth();
|
|
|
|
log("Enter synchronized thread method");
|
|
|
|
DebugMonitorInfo monitorInfo = new DebugMonitorInfo(this, currentStackDepth, this, false);
|
|
addMonitorInfo(monitorInfo);
|
|
createStackFrame();
|
|
removeMonitorInfo(monitorInfo);
|
|
|
|
log("Exit synchronized thread method");
|
|
}
|
|
|
|
void synchronizedThisBlock() {
|
|
int currentStackDepth = expectedDepth();
|
|
|
|
log("Enter synchronized(this) block");
|
|
|
|
synchronized (this) {
|
|
DebugMonitorInfo monitorInfo = new DebugMonitorInfo(this, currentStackDepth, this, false);
|
|
addMonitorInfo(monitorInfo);
|
|
createStackFrame();
|
|
removeMonitorInfo(monitorInfo);
|
|
}
|
|
|
|
log("Exit synchronized(this) block");
|
|
}
|
|
|
|
private static Object staticObject;
|
|
|
|
// 'staticObjectInitializingLock' is used in synchronizedBlockStaticObject() and synchronizedBlockStaticThreadObject().
|
|
// In this methods LockingThread initializes static object and enters in synchronized block
|
|
// for this static object, this actions are not thread safe(because of static fields are used) and 'staticObjectInitializingLock'
|
|
// is used to prevent races
|
|
private static ReentrantLock staticObjectInitializingLock = new ReentrantLock();
|
|
|
|
void synchronizedBlockStaticObject() {
|
|
int currentStackDepth = expectedDepth();
|
|
|
|
// initializing of 'staticObject' and entering to the synchronized(staticObject) block should be thread safe
|
|
staticObjectInitializingLock.lock();
|
|
|
|
staticObject = new Object();
|
|
|
|
log("Enter synchronized(static object) block");
|
|
|
|
synchronized (staticObject) {
|
|
// thread unsafe actions was done
|
|
staticObjectInitializingLock.unlock();
|
|
|
|
DebugMonitorInfo monitorInfo = new DebugMonitorInfo(staticObject, currentStackDepth, this, false);
|
|
addMonitorInfo(monitorInfo);
|
|
createStackFrame();
|
|
removeMonitorInfo(monitorInfo);
|
|
}
|
|
|
|
log("Exit synchronized(static object) block");
|
|
}
|
|
|
|
private static LockingThread staticLockingThread;
|
|
|
|
void synchronizedBlockStaticThreadObject() {
|
|
int currentStackDepth = expectedDepth();
|
|
|
|
// initializing of 'staticLockingThread' and entering to the synchronized(staticLockingThread) block should be thread safe
|
|
staticObjectInitializingLock.lock();
|
|
|
|
staticLockingThread = this;
|
|
|
|
log("Enter synchronized(static thread object) block");
|
|
|
|
synchronized (staticLockingThread) {
|
|
// thread unsafe actions was done
|
|
staticObjectInitializingLock.unlock();
|
|
|
|
DebugMonitorInfo monitorInfo = new DebugMonitorInfo(staticLockingThread, currentStackDepth, this, false);
|
|
addMonitorInfo(monitorInfo);
|
|
createStackFrame();
|
|
removeMonitorInfo(monitorInfo);
|
|
}
|
|
|
|
log("Exit synchronized(static thread object) block");
|
|
}
|
|
|
|
void synchronizedObjectBlock() {
|
|
int currentStackDepth = expectedDepth();
|
|
|
|
Object object = new Object();
|
|
|
|
log("Enter synchronized(object) block");
|
|
|
|
synchronized (object) {
|
|
DebugMonitorInfo monitorInfo = new DebugMonitorInfo(object, currentStackDepth, this, false);
|
|
addMonitorInfo(monitorInfo);
|
|
createStackFrame();
|
|
removeMonitorInfo(monitorInfo);
|
|
}
|
|
|
|
log("Exit synchronized(object) block");
|
|
}
|
|
|
|
private void frameWithoutLock() {
|
|
log("Enter frameWithoutLock");
|
|
|
|
createStackFrame();
|
|
|
|
for (DebugMonitorInfo monitor : monitorsInfo)
|
|
monitor.stackDepth -= 2;
|
|
|
|
log("Exit frameWithoutLock");
|
|
}
|
|
}
|
|
|
|
//class containing synchronized method and synchronized static method, used by LockingThread
|
|
class ClassWithSynchronizedMethods {
|
|
public synchronized void synchronizedMethod(LockingThread lockingThread) {
|
|
int currentStackDepth = lockingThread.expectedDepth();
|
|
|
|
lockingThread.log("Enter synchronized method");
|
|
|
|
LockingThread.DebugMonitorInfo monitorInfo = new LockingThread.DebugMonitorInfo(this, currentStackDepth, lockingThread, false);
|
|
lockingThread.addMonitorInfo(monitorInfo);
|
|
lockingThread.createStackFrame();
|
|
lockingThread.removeMonitorInfo(monitorInfo);
|
|
|
|
lockingThread.log("Exit synchronized method");
|
|
}
|
|
|
|
public static synchronized void synchronizedStaticMethod(LockingThread lockingThread) {
|
|
int currentStackDepth = lockingThread.expectedDepth();
|
|
|
|
lockingThread.log("Enter synchronized static method");
|
|
|
|
LockingThread.DebugMonitorInfo monitorInfo = new LockingThread.DebugMonitorInfo(ClassWithSynchronizedMethods.class, currentStackDepth,
|
|
lockingThread, false);
|
|
lockingThread.addMonitorInfo(monitorInfo);
|
|
lockingThread.createStackFrame();
|
|
lockingThread.removeMonitorInfo(monitorInfo);
|
|
|
|
lockingThread.log("Exit synchronized static method");
|
|
}
|
|
}
|