203 lines
8.0 KiB
Java
203 lines
8.0 KiB
Java
/*
|
|
* Copyright (c) 2019, 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 8213397 8217337
|
|
* @summary Check that the thread dump shows when a thread is blocked
|
|
* on a class initialization monitor
|
|
*
|
|
* @library /test/lib
|
|
* @run main/othervm TestThreadDumpClassInitMonitor
|
|
*/
|
|
|
|
import jdk.test.lib.process.OutputAnalyzer;
|
|
import jdk.test.lib.JDKToolFinder;
|
|
import jdk.test.lib.Platform;
|
|
|
|
import java.io.IOException;
|
|
import java.util.List;
|
|
|
|
public class TestThreadDumpClassInitMonitor {
|
|
// jstack tends to be closely bound to the VM that we are running
|
|
// so use getTestJDKTool() instead of getCompileJDKTool() or even
|
|
// getJDKTool() which can fall back to "compile.jdk".
|
|
final static String JSTACK = JDKToolFinder.getTestJDKTool("jstack");
|
|
final static String PID = "" + ProcessHandle.current().pid();
|
|
|
|
final static Thread current = Thread.currentThread();
|
|
|
|
/*
|
|
* This is the output we're looking for:
|
|
*
|
|
* "TestThread" #22 prio=5 os_prio=0 cpu=1.19ms elapsed=0.80s tid=0x00007f8f9405d800 nid=0x568b in Object.wait() [0x00007f8fd94d0000]
|
|
* java.lang.Thread.State: RUNNABLE
|
|
* Thread: 0x00007f8f9405d800 [0x568b] State: _at_safepoint _has_called_back 0 _at_poll_safepoint 0 // DEBUG ONLY
|
|
* JavaThread state: _thread_blocked // DEBUG ONLY
|
|
* at TestThreadDumpClassInitMonitor$Target$1.run(TestThreadDumpClassInitMonitor.java:69)
|
|
* - waiting on the Class initialization monitor for TestThreadDumpClassInitMonitor$Target
|
|
*
|
|
*/
|
|
final static String TEST_THREAD = "TestThread";
|
|
final static String TEST_THREAD_ENTRY = "\"" + TEST_THREAD;
|
|
final static String IN_OBJECT_WAIT = "in Object.wait()";
|
|
final static String THREAD_STATE = "java.lang.Thread.State: RUNNABLE";
|
|
final static String THREAD_INFO = "Thread:"; // the details are not important
|
|
final static String JAVATHREAD_STATE = "JavaThread state: _thread_blocked";
|
|
final static String CURRENT_METHOD = "at TestThreadDumpClassInitMonitor$Target$1.run";
|
|
final static String WAIT_INFO = "- waiting on the Class initialization monitor for TestThreadDumpClassInitMonitor$Target";
|
|
|
|
volatile static boolean ready = false;
|
|
|
|
static List<String> stackDump; // jstack output as lines
|
|
|
|
static class Target {
|
|
|
|
static int field;
|
|
|
|
// The main thread will initialize this class and so
|
|
// execute the actual test logic here.
|
|
static {
|
|
if (Thread.currentThread() != current) {
|
|
throw new Error("Initialization logic error");
|
|
}
|
|
System.out.println("Initializing Target class in main thread");
|
|
|
|
Thread t = new Thread() {
|
|
public void run() {
|
|
System.out.println("Test thread about to access Target");
|
|
ready = true; // tell main thread we're close
|
|
// This will block until the main thread completes
|
|
// static initialization of target
|
|
Target.field = 42;
|
|
System.out.println("Test thread done");
|
|
}
|
|
};
|
|
t.setName(TEST_THREAD);
|
|
t.start();
|
|
|
|
// We want to run jstack once the test thread is blocked but
|
|
// there's no programmatic way to detect that. So we check the flag
|
|
// that will be set just before it should block, then by the time
|
|
// we can exec jstack it should be ready.
|
|
try {
|
|
while (!ready) {
|
|
Thread.sleep(200);
|
|
}
|
|
}
|
|
catch (InterruptedException ie) {
|
|
throw new Error("Shouldn't happen");
|
|
}
|
|
|
|
// Now run jstack
|
|
try {
|
|
ProcessBuilder pb = new ProcessBuilder(JSTACK, PID);
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
output.shouldHaveExitValue(0);
|
|
stackDump = output.asLines();
|
|
}
|
|
catch (IOException ioe) {
|
|
throw new Error("Launching jstack failed", ioe);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static void main(String[] args) throws Throwable {
|
|
// Implicitly run the main test logic
|
|
Target.field = 21;
|
|
|
|
// Now check the output of jstack
|
|
try {
|
|
// product builds miss 2 lines of information in the stack
|
|
boolean isProduct = !Platform.isDebugBuild();
|
|
int foundLines = 0;
|
|
parseStack: for (String line : stackDump) {
|
|
switch(foundLines) {
|
|
case 0: {
|
|
if (!line.startsWith(TEST_THREAD_ENTRY)) {
|
|
continue;
|
|
}
|
|
foundLines++;
|
|
if (!line.contains(IN_OBJECT_WAIT)) {
|
|
throw new Error("Unexpected initial stack line: " + line);
|
|
}
|
|
continue;
|
|
}
|
|
case 1: {
|
|
if (!line.trim().equals(THREAD_STATE)) {
|
|
throw new Error("Unexpected thread state line: " + line);
|
|
}
|
|
if (isProduct) {
|
|
foundLines += 3;
|
|
} else {
|
|
foundLines++;
|
|
}
|
|
continue;
|
|
}
|
|
case 2: { // Debug build
|
|
if (!line.startsWith(THREAD_INFO)) {
|
|
throw new Error("Unexpected thread info line: " + line);
|
|
}
|
|
foundLines++;
|
|
continue;
|
|
}
|
|
case 3: { // Debug build
|
|
if (!line.trim().equals(JAVATHREAD_STATE)) {
|
|
throw new Error("Unexpected JavaThread state line: " + line);
|
|
}
|
|
foundLines++;
|
|
continue;
|
|
}
|
|
case 4: {
|
|
if (!line.trim().startsWith(CURRENT_METHOD)) {
|
|
throw new Error("Unexpected current method line: " + line);
|
|
}
|
|
foundLines++;
|
|
continue;
|
|
}
|
|
case 5: {
|
|
if (!line.trim().equals(WAIT_INFO)) {
|
|
throw new Error("Unexpected monitor information line: " + line);
|
|
}
|
|
break parseStack;
|
|
}
|
|
default: throw new Error("Logic error in case statement");
|
|
}
|
|
}
|
|
|
|
if (foundLines == 0) {
|
|
throw new Error("Unexpected stack content - did not find line starting with "
|
|
+ TEST_THREAD_ENTRY);
|
|
}
|
|
}
|
|
catch (Error e) {
|
|
// Dump the full stack trace on error so we can check the content
|
|
for (String line : stackDump) {
|
|
System.out.println(line);
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
}
|