532 lines
18 KiB
Java
532 lines
18 KiB
Java
|
/*
|
||
|
|
* Copyright 2003-2005 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||
|
|
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||
|
|
* have any questions.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @test
|
||
|
|
* @bug 4530538
|
||
|
|
* @summary Basic unit test of the synchronization statistics support:
|
||
|
|
*
|
||
|
|
* @author Mandy Chung
|
||
|
|
*
|
||
|
|
* @ignore 6309226
|
||
|
|
* @build Semaphore
|
||
|
|
* @run main SynchronizationStatistics
|
||
|
|
*/
|
||
|
|
|
||
|
|
import java.lang.management.*;
|
||
|
|
|
||
|
|
public class SynchronizationStatistics {
|
||
|
|
private static ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
|
||
|
|
|
||
|
|
private static boolean blockedTimeCheck =
|
||
|
|
mbean.isThreadContentionMonitoringSupported();
|
||
|
|
private static boolean trace = false;
|
||
|
|
|
||
|
|
private static Object lockA = new Object();
|
||
|
|
private static Object lockB = new Object();
|
||
|
|
private static Object lockC = new Object();
|
||
|
|
private static Object lockD = new Object();
|
||
|
|
private static Object waiter = new Object();
|
||
|
|
private static volatile boolean testFailed = false;
|
||
|
|
|
||
|
|
private static Object go = new Object();
|
||
|
|
|
||
|
|
private static void goSleep(long ms) {
|
||
|
|
try {
|
||
|
|
Thread.sleep(ms);
|
||
|
|
} catch (InterruptedException e) {
|
||
|
|
e.printStackTrace();
|
||
|
|
System.out.println("Unexpected exception.");
|
||
|
|
testFailed = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void main(String args[]) throws Exception {
|
||
|
|
if (args.length > 0 && args[0].equals("trace")) {
|
||
|
|
trace = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (blockedTimeCheck) {
|
||
|
|
mbean.setThreadContentionMonitoringEnabled(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!mbean.isThreadContentionMonitoringEnabled()) {
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Thread Contention Monitoring is not enabled");
|
||
|
|
}
|
||
|
|
|
||
|
|
Examiner examiner = new Examiner("Examiner");
|
||
|
|
BlockedThread blocked = new BlockedThread("BlockedThread");
|
||
|
|
examiner.setThread(blocked);
|
||
|
|
|
||
|
|
// Start the threads and check them in Blocked and Waiting states
|
||
|
|
examiner.start();
|
||
|
|
|
||
|
|
// wait until the examiner acquires all the locks and waiting
|
||
|
|
// for the BlockedThread to start
|
||
|
|
examiner.waitUntilWaiting();
|
||
|
|
|
||
|
|
System.out.println("Checking the thread state for the examiner thread " +
|
||
|
|
"is waiting to begin.");
|
||
|
|
|
||
|
|
// The Examiner should be waiting to be notified by the BlockedThread
|
||
|
|
checkThreadState(examiner, Thread.State.WAITING);
|
||
|
|
|
||
|
|
System.out.println("Now starting the blocked thread");
|
||
|
|
blocked.start();
|
||
|
|
|
||
|
|
try {
|
||
|
|
examiner.join();
|
||
|
|
blocked.join();
|
||
|
|
} catch (InterruptedException e) {
|
||
|
|
e.printStackTrace();
|
||
|
|
System.out.println("Unexpected exception.");
|
||
|
|
testFailed = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (testFailed)
|
||
|
|
throw new RuntimeException("TEST FAILED.");
|
||
|
|
|
||
|
|
System.out.println("Test passed.");
|
||
|
|
}
|
||
|
|
|
||
|
|
private static String INDENT = " ";
|
||
|
|
private static void printStack(Thread t, StackTraceElement[] stack) {
|
||
|
|
System.out.println(INDENT + t +
|
||
|
|
" stack: (length = " + stack.length + ")");
|
||
|
|
if (t != null) {
|
||
|
|
for (int j = 0; j < stack.length; j++) {
|
||
|
|
System.out.println(INDENT + stack[j]);
|
||
|
|
}
|
||
|
|
System.out.println();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static void checkThreadState(Thread thread, Thread.State s)
|
||
|
|
throws Exception {
|
||
|
|
|
||
|
|
ThreadInfo ti = mbean.getThreadInfo(thread.getId());
|
||
|
|
if (ti.getThreadState() != s) {
|
||
|
|
ThreadInfo info = mbean.getThreadInfo(thread.getId(),
|
||
|
|
Integer.MAX_VALUE);
|
||
|
|
System.out.println(INDENT + "TEST FAILED:");
|
||
|
|
printStack(thread, info.getStackTrace());
|
||
|
|
System.out.println(INDENT + "Thread state: " + info.getThreadState());
|
||
|
|
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Thread state for " + thread + " returns " + ti.getThreadState() +
|
||
|
|
". Expected to be " + s);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static void checkThreadState(Thread thread,
|
||
|
|
Thread.State s1, Thread.State s2)
|
||
|
|
throws Exception {
|
||
|
|
|
||
|
|
ThreadInfo ti = mbean.getThreadInfo(thread.getId());
|
||
|
|
if (ti.getThreadState() != s1 && ti.getThreadState() != s2) {
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Thread state for " + thread + " returns " + ti.getThreadState() +
|
||
|
|
". Expected to be " + s1 + " or " + s2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static class StatThread extends Thread {
|
||
|
|
private long blockingBaseTime = 0;
|
||
|
|
private long totalWaitTime = 0;
|
||
|
|
private long totalBlockedEnterTime = 0;
|
||
|
|
|
||
|
|
StatThread(String name) {
|
||
|
|
super(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
void addWaitTime(long ns) {
|
||
|
|
totalWaitTime = totalWaitTime + ns;
|
||
|
|
}
|
||
|
|
void addBlockedEnterTime(long ns) {
|
||
|
|
totalBlockedEnterTime = totalBlockedEnterTime + ns;
|
||
|
|
}
|
||
|
|
void setBlockingBaseTime(long time) {
|
||
|
|
blockingBaseTime = time;
|
||
|
|
}
|
||
|
|
|
||
|
|
long totalBlockedTimeMs() {
|
||
|
|
return totalBlockedEnterTime / 1000000;
|
||
|
|
}
|
||
|
|
|
||
|
|
long totalBlockedTimeMs(long now) {
|
||
|
|
long t = totalBlockedEnterTime + (now - blockingBaseTime);
|
||
|
|
return t / 1000000;
|
||
|
|
}
|
||
|
|
|
||
|
|
long totalWaitTimeMs() {
|
||
|
|
return totalWaitTime / 1000000;
|
||
|
|
}
|
||
|
|
|
||
|
|
long totalWaitTimeMs(long now) {
|
||
|
|
long t = totalWaitTime + (now - blockingBaseTime);
|
||
|
|
return t / 1000000;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static class BlockedThread extends StatThread {
|
||
|
|
private Semaphore handshake = new Semaphore();
|
||
|
|
BlockedThread(String name) {
|
||
|
|
super(name);
|
||
|
|
}
|
||
|
|
void waitUntilBlocked() {
|
||
|
|
handshake.semaP();
|
||
|
|
|
||
|
|
// give a chance for the examiner thread to really wait
|
||
|
|
goSleep(20);
|
||
|
|
}
|
||
|
|
|
||
|
|
void waitUntilWaiting() {
|
||
|
|
waitUntilBlocked();
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean hasWaitersForBlocked() {
|
||
|
|
return (handshake.getWaiterCount() > 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void notifyWaiter() {
|
||
|
|
// wait until the examiner waits on the semaphore
|
||
|
|
while (handshake.getWaiterCount() == 0) {
|
||
|
|
goSleep(20);
|
||
|
|
}
|
||
|
|
handshake.semaV();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void waitObj(long ms) {
|
||
|
|
synchronized (waiter) {
|
||
|
|
try {
|
||
|
|
// notify examinerabout to wait on a monitor
|
||
|
|
notifyWaiter();
|
||
|
|
|
||
|
|
long base = System.nanoTime();
|
||
|
|
setBlockingBaseTime(base);
|
||
|
|
waiter.wait(ms);
|
||
|
|
long now = System.nanoTime();
|
||
|
|
addWaitTime(now - base);
|
||
|
|
} catch (Exception e) {
|
||
|
|
e.printStackTrace();
|
||
|
|
System.out.println("Unexpected exception.");
|
||
|
|
testFailed = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void test() {
|
||
|
|
// notify examiner about to block on lockA
|
||
|
|
notifyWaiter();
|
||
|
|
|
||
|
|
long base = System.nanoTime();
|
||
|
|
setBlockingBaseTime(base);
|
||
|
|
synchronized (lockA) {
|
||
|
|
long now = System.nanoTime();
|
||
|
|
addBlockedEnterTime(now - base);
|
||
|
|
|
||
|
|
A(); // Expected blocked count = 1
|
||
|
|
}
|
||
|
|
E();
|
||
|
|
}
|
||
|
|
private void A() {
|
||
|
|
// notify examiner about to block on lockB
|
||
|
|
notifyWaiter();
|
||
|
|
|
||
|
|
long base = System.nanoTime();
|
||
|
|
setBlockingBaseTime(base);
|
||
|
|
synchronized (lockB) {
|
||
|
|
long now = System.nanoTime();
|
||
|
|
addBlockedEnterTime(now - base);
|
||
|
|
|
||
|
|
B(); // Expected blocked count = 2
|
||
|
|
}
|
||
|
|
}
|
||
|
|
private void B() {
|
||
|
|
// notify examiner about to block on lockC
|
||
|
|
notifyWaiter();
|
||
|
|
|
||
|
|
long base = System.nanoTime();
|
||
|
|
setBlockingBaseTime(base);
|
||
|
|
synchronized (lockC) {
|
||
|
|
long now = System.nanoTime();
|
||
|
|
addBlockedEnterTime(now - base);
|
||
|
|
|
||
|
|
C(); // Expected blocked count = 3
|
||
|
|
}
|
||
|
|
}
|
||
|
|
private void C() {
|
||
|
|
// notify examiner about to block on lockD
|
||
|
|
notifyWaiter();
|
||
|
|
|
||
|
|
long base = System.nanoTime();
|
||
|
|
setBlockingBaseTime(base);
|
||
|
|
synchronized (lockD) {
|
||
|
|
long now = System.nanoTime();
|
||
|
|
addBlockedEnterTime(now - base);
|
||
|
|
|
||
|
|
D(); // Expected blocked count = 4
|
||
|
|
}
|
||
|
|
}
|
||
|
|
private void D() {
|
||
|
|
goSleep(50);
|
||
|
|
}
|
||
|
|
private void E() {
|
||
|
|
final int WAIT = 1000;
|
||
|
|
waitObj(WAIT);
|
||
|
|
waitObj(WAIT);
|
||
|
|
waitObj(WAIT);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void run() {
|
||
|
|
test();
|
||
|
|
} // run()
|
||
|
|
} // BlockedThread
|
||
|
|
|
||
|
|
static int blockedCount = 0;
|
||
|
|
static int waitedCount = 0;
|
||
|
|
static class Examiner extends StatThread {
|
||
|
|
private BlockedThread blockedThread;
|
||
|
|
private Semaphore semaphore = new Semaphore();
|
||
|
|
|
||
|
|
Examiner(String name) {
|
||
|
|
super(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void setThread(BlockedThread thread) {
|
||
|
|
blockedThread = thread;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void blockedTimeRangeCheck(StatThread t,
|
||
|
|
long blockedTime,
|
||
|
|
long nowNano)
|
||
|
|
throws Exception {
|
||
|
|
long expected = t.totalBlockedTimeMs(nowNano);
|
||
|
|
|
||
|
|
// accept 5% range
|
||
|
|
timeRangeCheck(blockedTime, expected, 5);
|
||
|
|
}
|
||
|
|
private void waitedTimeRangeCheck(StatThread t,
|
||
|
|
long waitedTime,
|
||
|
|
long nowNano)
|
||
|
|
throws Exception {
|
||
|
|
long expected = t.totalWaitTimeMs(nowNano);
|
||
|
|
|
||
|
|
// accept 5% range
|
||
|
|
timeRangeCheck(waitedTime, expected, 5);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void timeRangeCheck(long time, long expected, int percent)
|
||
|
|
throws Exception {
|
||
|
|
|
||
|
|
double diff = expected - time;
|
||
|
|
|
||
|
|
if (trace) {
|
||
|
|
System.out.println(" Time = " + time +
|
||
|
|
" expected = " + expected +
|
||
|
|
". Diff = " + diff);
|
||
|
|
|
||
|
|
}
|
||
|
|
// throw an exception if blockedTime and expectedTime
|
||
|
|
// differs > percent%
|
||
|
|
if (diff < 0) {
|
||
|
|
diff = diff * -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
long range = (expected * percent) / 100;
|
||
|
|
// minimum range = 2 ms
|
||
|
|
if (range < 2) {
|
||
|
|
range = 2;
|
||
|
|
}
|
||
|
|
if (diff > range) {
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Time returned = " + time +
|
||
|
|
" expected = " + expected + ". Diff = " + diff);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
private void checkInfo(StatThread t, Thread.State s, Object lock,
|
||
|
|
String lockName, int bcount, int wcount)
|
||
|
|
throws Exception {
|
||
|
|
|
||
|
|
String action = "ERROR";
|
||
|
|
if (s == Thread.State.WAITING || s == Thread.State.TIMED_WAITING) {
|
||
|
|
action = "wait on ";
|
||
|
|
} else if (s == Thread.State.BLOCKED) {
|
||
|
|
action = "block on ";
|
||
|
|
}
|
||
|
|
System.out.println(t + " expected to " + action + lockName +
|
||
|
|
" with blocked count = " + bcount +
|
||
|
|
" and waited count = " + wcount);
|
||
|
|
|
||
|
|
long now = System.nanoTime();
|
||
|
|
ThreadInfo info = mbean.getThreadInfo(t.getId());
|
||
|
|
if (info.getThreadState() != s) {
|
||
|
|
printStack(t, info.getStackTrace());
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Thread state returned is " + info.getThreadState() +
|
||
|
|
". Expected to be " + s);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (info.getLockName() == null ||
|
||
|
|
!info.getLockName().equals(lock.toString())) {
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"getLockName() returned " + info.getLockName() +
|
||
|
|
". Expected to be " + lockName + " - " + lock.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
if (info.getBlockedCount() != bcount) {
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Blocked Count returned is " + info.getBlockedCount() +
|
||
|
|
". Expected to be " + bcount);
|
||
|
|
}
|
||
|
|
if (info.getWaitedCount() != wcount) {
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Waited Count returned is " + info.getWaitedCount() +
|
||
|
|
". Expected to be " + wcount);
|
||
|
|
}
|
||
|
|
|
||
|
|
String lockObj = info.getLockName();
|
||
|
|
if (lockObj == null || !lockObj.equals(lock.toString())) {
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Object blocked on is " + lockObj +
|
||
|
|
". Expected to be " + lock.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!blockedTimeCheck) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
long blockedTime = info.getBlockedTime();
|
||
|
|
if (blockedTime < 0) {
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Blocked time returned is negative = " + blockedTime);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (s == Thread.State.BLOCKED) {
|
||
|
|
blockedTimeRangeCheck(t, blockedTime, now);
|
||
|
|
} else {
|
||
|
|
timeRangeCheck(blockedTime, t.totalBlockedTimeMs(), 5);
|
||
|
|
}
|
||
|
|
|
||
|
|
long waitedTime = info.getWaitedTime();
|
||
|
|
if (waitedTime < 0) {
|
||
|
|
throw new RuntimeException("TEST FAILED: " +
|
||
|
|
"Waited time returned is negative = " + waitedTime);
|
||
|
|
}
|
||
|
|
if (s == Thread.State.WAITING || s == Thread.State.TIMED_WAITING) {
|
||
|
|
waitedTimeRangeCheck(t, waitedTime, now);
|
||
|
|
} else {
|
||
|
|
timeRangeCheck(waitedTime, t.totalWaitTimeMs(), 5);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
private void examine() {
|
||
|
|
try {
|
||
|
|
synchronized (lockD) {
|
||
|
|
synchronized (lockC) {
|
||
|
|
synchronized (lockB) {
|
||
|
|
synchronized (lockA) {
|
||
|
|
// notify main thread to continue
|
||
|
|
semaphore.semaV();
|
||
|
|
|
||
|
|
// wait until BlockedThread has started
|
||
|
|
blockedThread.waitUntilBlocked();
|
||
|
|
|
||
|
|
blockedCount++;
|
||
|
|
checkInfo(blockedThread, Thread.State.BLOCKED,
|
||
|
|
lockA, "lockA",
|
||
|
|
blockedCount, waitedCount);
|
||
|
|
}
|
||
|
|
|
||
|
|
// wait until BlockedThread to block on lockB
|
||
|
|
blockedThread.waitUntilBlocked();
|
||
|
|
|
||
|
|
blockedCount++;
|
||
|
|
checkInfo(blockedThread, Thread.State.BLOCKED,
|
||
|
|
lockB, "lockB",
|
||
|
|
blockedCount, waitedCount);
|
||
|
|
}
|
||
|
|
|
||
|
|
// wait until BlockedThread to block on lockC
|
||
|
|
blockedThread.waitUntilBlocked();
|
||
|
|
|
||
|
|
blockedCount++;
|
||
|
|
checkInfo(blockedThread, Thread.State.BLOCKED,
|
||
|
|
lockC, "lockC",
|
||
|
|
blockedCount, waitedCount);
|
||
|
|
}
|
||
|
|
// wait until BlockedThread to block on lockD
|
||
|
|
blockedThread.waitUntilBlocked();
|
||
|
|
blockedCount++;
|
||
|
|
|
||
|
|
checkInfo(blockedThread, Thread.State.BLOCKED,
|
||
|
|
lockD, "lockD",
|
||
|
|
blockedCount, waitedCount);
|
||
|
|
}
|
||
|
|
|
||
|
|
// wait until BlockedThread about to call E()
|
||
|
|
// BlockedThread will wait on waiter for 3 times
|
||
|
|
blockedThread.waitUntilWaiting();
|
||
|
|
|
||
|
|
waitedCount++;
|
||
|
|
checkInfo(blockedThread, Thread.State.TIMED_WAITING,
|
||
|
|
waiter, "waiter", blockedCount, waitedCount);
|
||
|
|
|
||
|
|
blockedThread.waitUntilWaiting();
|
||
|
|
|
||
|
|
waitedCount++;
|
||
|
|
checkInfo(blockedThread, Thread.State.TIMED_WAITING,
|
||
|
|
waiter, "waiter", blockedCount, waitedCount);
|
||
|
|
|
||
|
|
blockedThread.waitUntilWaiting();
|
||
|
|
|
||
|
|
waitedCount++;
|
||
|
|
checkInfo(blockedThread, Thread.State.TIMED_WAITING,
|
||
|
|
waiter, "waiter", blockedCount, waitedCount);
|
||
|
|
|
||
|
|
} catch (Exception e) {
|
||
|
|
e.printStackTrace();
|
||
|
|
System.out.println("Unexpected exception.");
|
||
|
|
testFailed = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void run() {
|
||
|
|
examine();
|
||
|
|
} // run()
|
||
|
|
|
||
|
|
public void waitUntilWaiting() {
|
||
|
|
semaphore.semaP();
|
||
|
|
|
||
|
|
// wait until the examiner is waiting for
|
||
|
|
while (!blockedThread.hasWaitersForBlocked()) {
|
||
|
|
goSleep(50);
|
||
|
|
}
|
||
|
|
// give a chance for the examiner thread to really wait
|
||
|
|
goSleep(20);
|
||
|
|
|
||
|
|
}
|
||
|
|
} // Examiner
|
||
|
|
}
|