416 lines
17 KiB
Java
416 lines
17 KiB
Java
/*
|
|
* Copyright (c) 2001, 2021, 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.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8167108 8265153
|
|
* @summary The test checks that ThreadInfo.getLockOwnerName() returns a
|
|
* non-null string for a blocked thread and then makes repeated calls
|
|
* to getThreadInfo() and ThreadInfo.getLockOwnerName() until the thread
|
|
* has exited.
|
|
* @requires vm.jvmti
|
|
* @run main/othervm/native -agentlib:GetLockOwnerName GetLockOwnerName
|
|
*/
|
|
|
|
import java.io.PrintStream;
|
|
import java.lang.management.ManagementFactory;
|
|
import java.lang.management.ThreadInfo;
|
|
import java.lang.management.ThreadMXBean;
|
|
|
|
//
|
|
// main blocker contender releaser
|
|
// ================= ================ =================== ================
|
|
// launch blocker
|
|
// <launch returns> blocker running
|
|
// launch contender enter threadLock
|
|
// <launch returns> wait for notify contender running
|
|
// launch releaser : block on threadLock
|
|
// <launch returns> : : releaser running
|
|
// wait for : : wait for notify
|
|
// contended enter : : :
|
|
// <ready to test> : : :
|
|
// getThreadInfo : : :
|
|
// verify contender : : :
|
|
// lock owner name : : :
|
|
// is "blocker" : : :
|
|
// notify releaser : : :
|
|
// loop until thread : : wait finishes
|
|
// is NULL : : notify blocker
|
|
// get thread info wait finishes : releaser exits
|
|
// get lock owner exit threadLock : :
|
|
// name blocker exits enter threadLock :
|
|
// join releaser : exit threadLock <exit finishes>
|
|
// <join returns> : contender exits
|
|
// join blocker <exit finishes> :
|
|
// <join returns> :
|
|
// join contender <exit finishes>
|
|
// <join returns>
|
|
//
|
|
|
|
public class GetLockOwnerName {
|
|
private static final String AGENT_LIB = "GetLockOwnerName";
|
|
|
|
private static final int DEF_TIME_MAX = 60; // default max # secs to test
|
|
private static final int JOIN_MAX = 30; // max # secs to wait for join
|
|
|
|
public static final int TS_INIT = 1; // initial testState
|
|
public static final int TS_BLOCKER_RUNNING = 2; // blocker is running
|
|
public static final int TS_CONTENDER_RUNNING = 3; // contender is running
|
|
public static final int TS_RELEASER_RUNNING = 4; // releaser is running
|
|
public static final int TS_CONTENDER_BLOCKED = 5; // contender is blocked
|
|
public static final int TS_READY_TO_RELEASE = 6; // ready to release the blocker
|
|
public static final int TS_DONE_BLOCKING = 7; // done blocking threadLock
|
|
public static final int TS_CONTENDER_DONE = 8; // contender has run; done
|
|
|
|
public static Object barrierLaunch = new Object(); // controls thread launch
|
|
public static Object barrierBlocker = new Object(); // controls blocker
|
|
public static Object barrierReleaser = new Object(); // controls releaser
|
|
public static Object threadLock = new Object(); // testing object
|
|
|
|
public static long count = 0;
|
|
public static boolean printDebug = false;
|
|
public volatile static int testState;
|
|
|
|
private static void log(String msg) { System.out.println(msg); }
|
|
|
|
native static int wait4ContendedEnter(GetLockOwnerNameWorker thr);
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
try {
|
|
System.loadLibrary(AGENT_LIB);
|
|
log("Loaded library: " + AGENT_LIB);
|
|
} catch (UnsatisfiedLinkError ule) {
|
|
log("Failed to load library: " + AGENT_LIB);
|
|
log("java.library.path: " + System.getProperty("java.library.path"));
|
|
throw ule;
|
|
}
|
|
|
|
int timeMax = 0;
|
|
if (args.length == 0) {
|
|
timeMax = DEF_TIME_MAX;
|
|
} else {
|
|
int argIndex = 0;
|
|
int argsLeft = args.length;
|
|
if (args[0].equals("-p")) {
|
|
printDebug = true;
|
|
argIndex = 1;
|
|
argsLeft--;
|
|
}
|
|
if (argsLeft == 0) {
|
|
timeMax = DEF_TIME_MAX;
|
|
} else if (argsLeft == 1) {
|
|
try {
|
|
timeMax = Integer.parseUnsignedInt(args[argIndex]);
|
|
} catch (NumberFormatException nfe) {
|
|
System.err.println("'" + args[argIndex] +
|
|
"': invalid timeMax value.");
|
|
usage();
|
|
}
|
|
} else {
|
|
usage();
|
|
}
|
|
}
|
|
|
|
int retCode = run(timeMax, System.out);
|
|
if (retCode != 0) {
|
|
throw new RuntimeException("Test failed with retCode=" + retCode);
|
|
}
|
|
}
|
|
|
|
public static void logDebug(String mesg) {
|
|
if (printDebug) {
|
|
System.err.println(Thread.currentThread().getName() + ": " + mesg);
|
|
}
|
|
}
|
|
|
|
public static void usage() {
|
|
System.err.println("Usage: " + AGENT_LIB + " [-p][time_max]");
|
|
System.err.println("where:");
|
|
System.err.println(" -p print debug info");
|
|
System.err.println(" time_max max looping time in seconds");
|
|
System.err.println(" (default is " + DEF_TIME_MAX +
|
|
" seconds)");
|
|
System.exit(1);
|
|
}
|
|
|
|
public static int run(int timeMax, PrintStream out) {
|
|
return (new GetLockOwnerName()).doWork(timeMax, out);
|
|
}
|
|
|
|
public static void checkTestState(int exp) {
|
|
if (testState != exp) {
|
|
System.err.println("Failure at " + count + " loops.");
|
|
throw new InternalError("Unexpected test state value: "
|
|
+ "expected=" + exp + " actual=" + testState);
|
|
}
|
|
}
|
|
|
|
public int doWork(int timeMax, PrintStream out) {
|
|
ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
|
|
|
|
GetLockOwnerNameWorker blocker; // blocker thread
|
|
GetLockOwnerNameWorker contender; // contender thread
|
|
GetLockOwnerNameWorker releaser; // releaser thread
|
|
|
|
System.out.println("About to execute for " + timeMax + " seconds.");
|
|
|
|
long start_time = System.currentTimeMillis();
|
|
while (System.currentTimeMillis() < start_time + (timeMax * 1000)) {
|
|
count++;
|
|
testState = TS_INIT; // starting the test loop
|
|
|
|
// launch the blocker thread
|
|
synchronized (barrierLaunch) {
|
|
blocker = new GetLockOwnerNameWorker("blocker");
|
|
blocker.start();
|
|
|
|
while (testState != TS_BLOCKER_RUNNING) {
|
|
try {
|
|
barrierLaunch.wait(); // wait until it is running
|
|
} catch (InterruptedException ex) {
|
|
}
|
|
}
|
|
}
|
|
|
|
// launch the contender thread
|
|
synchronized (barrierLaunch) {
|
|
contender = new GetLockOwnerNameWorker("contender");
|
|
contender.start();
|
|
|
|
while (testState != TS_CONTENDER_RUNNING) {
|
|
try {
|
|
barrierLaunch.wait(); // wait until it is running
|
|
} catch (InterruptedException ex) {
|
|
}
|
|
}
|
|
}
|
|
|
|
// launch the releaser thread
|
|
synchronized (barrierLaunch) {
|
|
releaser = new GetLockOwnerNameWorker("releaser");
|
|
releaser.start();
|
|
|
|
while (testState != TS_RELEASER_RUNNING) {
|
|
try {
|
|
barrierLaunch.wait(); // wait until it is running
|
|
} catch (InterruptedException ex) {
|
|
}
|
|
}
|
|
}
|
|
|
|
// wait for the contender thread to block
|
|
logDebug("before contended enter wait");
|
|
int retCode = wait4ContendedEnter(contender);
|
|
if (retCode != 0) {
|
|
throw new RuntimeException("error in JVMTI GetThreadState " +
|
|
"or GetCurrentContendedMonitor " +
|
|
"retCode=" + retCode);
|
|
}
|
|
testState = TS_CONTENDER_BLOCKED;
|
|
logDebug("done contended enter wait");
|
|
|
|
//
|
|
// At this point, all of the child threads are running
|
|
// and we can get to meat of the test:
|
|
//
|
|
// - query the contender thread and verify that it is blocked
|
|
// by the blocker thread
|
|
// - tell the releaser thread to release the blocker thread
|
|
// - continue to query the contender thread until it exits
|
|
//
|
|
long id = 0;
|
|
ThreadInfo info = null;
|
|
int lateCount = 0;
|
|
|
|
checkTestState(TS_CONTENDER_BLOCKED);
|
|
|
|
id = contender.getId();
|
|
info = mbean.getThreadInfo(id, 0);
|
|
String name = info.getLockOwnerName();
|
|
|
|
if (name == null) {
|
|
out.println("Failure at " + count + " loops.");
|
|
throw new RuntimeException("ThreadInfo.GetLockOwnerName() "
|
|
+ "returned null name for "
|
|
+ "contender.");
|
|
} else if (!name.equals("blocker")) {
|
|
out.println("Failure at " + count + " loops.");
|
|
throw new RuntimeException("name='" + name + "': name "
|
|
+ "should be blocker.");
|
|
} else {
|
|
logDebug("ThreadInfo.GetLockOwnerName() returned blocker.");
|
|
}
|
|
|
|
synchronized (barrierReleaser) {
|
|
// tell releaser thread to release the blocker thread
|
|
testState = TS_READY_TO_RELEASE;
|
|
barrierReleaser.notify();
|
|
}
|
|
|
|
while (true) {
|
|
// maxDepth == 0 requires no safepoint so alternate.
|
|
int maxDepth = ((count % 1) == 1) ? Integer.MAX_VALUE : 0;
|
|
info = mbean.getThreadInfo(id, maxDepth);
|
|
if (info == null) {
|
|
// the contender has exited
|
|
break;
|
|
}
|
|
name = info.getLockOwnerName();
|
|
// We can't verify that name == null here because contender
|
|
// might be slow leaving the threadLock monitor.
|
|
lateCount++;
|
|
}
|
|
logDebug("made " + lateCount + " late calls to getThreadInfo() " +
|
|
"and info.getLockOwnerName().");
|
|
|
|
try {
|
|
releaser.join(JOIN_MAX * 1000);
|
|
if (releaser.isAlive()) {
|
|
System.err.println("Failure at " + count + " loops.");
|
|
throw new InternalError("releaser thread is stuck");
|
|
}
|
|
blocker.join(JOIN_MAX * 1000);
|
|
if (blocker.isAlive()) {
|
|
System.err.println("Failure at " + count + " loops.");
|
|
throw new InternalError("blocker thread is stuck");
|
|
}
|
|
contender.join(JOIN_MAX * 1000);
|
|
if (contender.isAlive()) {
|
|
System.err.println("Failure at " + count + " loops.");
|
|
throw new InternalError("contender thread is stuck");
|
|
}
|
|
} catch (InterruptedException ex) {
|
|
}
|
|
|
|
checkTestState(TS_CONTENDER_DONE);
|
|
}
|
|
|
|
System.out.println("Executed " + count + " loops in " + timeMax +
|
|
" seconds.");
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
class GetLockOwnerNameWorker extends Thread {
|
|
public GetLockOwnerNameWorker(String name) {
|
|
super(name);
|
|
}
|
|
|
|
public void run() {
|
|
GetLockOwnerName.logDebug("thread running");
|
|
|
|
//
|
|
// The blocker thread:
|
|
// - grabs threadLock
|
|
// - holds threadLock until we tell it let go
|
|
// - releases threadLock
|
|
//
|
|
if (getName().equals("blocker")) {
|
|
// grab threadLock before we tell main we are running
|
|
GetLockOwnerName.logDebug("before enter threadLock");
|
|
synchronized(GetLockOwnerName.threadLock) {
|
|
GetLockOwnerName.logDebug("enter threadLock");
|
|
|
|
GetLockOwnerName.checkTestState(GetLockOwnerName.TS_INIT);
|
|
|
|
synchronized(GetLockOwnerName.barrierBlocker) {
|
|
synchronized(GetLockOwnerName.barrierLaunch) {
|
|
// tell main we are running
|
|
GetLockOwnerName.testState = GetLockOwnerName.TS_BLOCKER_RUNNING;
|
|
GetLockOwnerName.barrierLaunch.notify();
|
|
}
|
|
GetLockOwnerName.logDebug("thread waiting");
|
|
while (GetLockOwnerName.testState != GetLockOwnerName.TS_DONE_BLOCKING) {
|
|
try {
|
|
// wait for main to tell us when to exit threadLock
|
|
GetLockOwnerName.barrierBlocker.wait();
|
|
} catch (InterruptedException ex) {
|
|
}
|
|
}
|
|
}
|
|
GetLockOwnerName.logDebug("exit threadLock");
|
|
}
|
|
}
|
|
//
|
|
// The contender thread:
|
|
// - tries to grab the threadLock
|
|
// - grabs threadLock
|
|
// - releases threadLock
|
|
//
|
|
else if (getName().equals("contender")) {
|
|
synchronized(GetLockOwnerName.barrierLaunch) {
|
|
// tell main we are running
|
|
GetLockOwnerName.testState = GetLockOwnerName.TS_CONTENDER_RUNNING;
|
|
GetLockOwnerName.barrierLaunch.notify();
|
|
}
|
|
|
|
GetLockOwnerName.logDebug("before enter threadLock");
|
|
synchronized(GetLockOwnerName.threadLock) {
|
|
GetLockOwnerName.logDebug("enter threadLock");
|
|
|
|
GetLockOwnerName.checkTestState(GetLockOwnerName.TS_DONE_BLOCKING);
|
|
GetLockOwnerName.testState = GetLockOwnerName.TS_CONTENDER_DONE;
|
|
|
|
GetLockOwnerName.logDebug("exit threadLock");
|
|
}
|
|
}
|
|
//
|
|
// The releaser thread:
|
|
// - tries to grab the barrierBlocker (should not block!)
|
|
// - grabs barrierBlocker
|
|
// - releases the blocker thread
|
|
// - releases barrierBlocker
|
|
//
|
|
else if (getName().equals("releaser")) {
|
|
synchronized(GetLockOwnerName.barrierReleaser) {
|
|
synchronized(GetLockOwnerName.barrierLaunch) {
|
|
// tell main we are running
|
|
GetLockOwnerName.testState = GetLockOwnerName.TS_RELEASER_RUNNING;
|
|
GetLockOwnerName.barrierLaunch.notify();
|
|
}
|
|
GetLockOwnerName.logDebug("thread waiting");
|
|
while (GetLockOwnerName.testState != GetLockOwnerName.TS_READY_TO_RELEASE) {
|
|
try {
|
|
// wait for main to tell us when to continue
|
|
GetLockOwnerName.barrierReleaser.wait();
|
|
} catch (InterruptedException ex) {
|
|
}
|
|
}
|
|
}
|
|
|
|
GetLockOwnerName.logDebug("before enter barrierBlocker");
|
|
synchronized (GetLockOwnerName.barrierBlocker) {
|
|
GetLockOwnerName.logDebug("enter barrierBlocker");
|
|
|
|
// tell blocker thread to exit threadLock
|
|
GetLockOwnerName.testState = GetLockOwnerName.TS_DONE_BLOCKING;
|
|
GetLockOwnerName.barrierBlocker.notify();
|
|
|
|
GetLockOwnerName.logDebug("released blocker thread");
|
|
GetLockOwnerName.logDebug("exit barrierBlocker");
|
|
}
|
|
}
|
|
}
|
|
}
|