jdk-sandbox: comparison jdk/test/java/lang/management/ThreadMXBean/Locks.java

equal deleted inserted replaced

-:d3f16ee13562
+:acc6f4bcb37e
 * @summary Basic unit test of ThreadInfo.getLockName()
 *          and ThreadInfo.getLockOwnerName()
 * @author  Mandy Chung
 * @author  Jaroslav Bachorik
 *
+* @library /lib/testlibrary
+* @build jdk.testlibrary.*
 * @run main/othervm Locks
 */
 import java.lang.management.*;
 import java.util.concurrent.Phaser;
+import jdk.testlibrary.LockFreeLogManager;
 public class Locks {
 private static final Object objA = new Object();
 private static final Object objB = new Object();
 private static final Object objC = new Object();
 private static final ThreadMXBean tm = ManagementFactory.getThreadMXBean();
+private static final LockFreeLogManager logger = new LockFreeLogManager();
 private static boolean testFailed = false;
 private static String getLockName(Object lock) {
 if (lock == null) return null;
 this.p = p;
 }
 public void run() {
 synchronized(objA) {
 // stop here  for LockBThread to hold objB
-System.out.println("LockAThread about to block on objB");
+log("LockAThread about to block on objB");
 p.arriveAndAwaitAdvance(); // Phase 1 (blocking)
 synchronized(objB) {
 dummyCounter++;
 };
 }
 p.arriveAndAwaitAdvance(); // Phase 2 (blocking)
-System.out.println("LockAThread about to exit");
+log("LockAThread about to exit");
 // Make sure the current thread is not holding any lock
 assertNoLock(this);
 }
 }
 super("LockBThread");
 this.p = p;
 }
 public void run() {
 synchronized(objB) {
-System.out.println("LockBThread about to block on objC");
+log("LockBThread about to block on objC");
 p.arriveAndAwaitAdvance(); // Phase 1 (blocking)
 // Signal main thread about to block on objC
 synchronized(objC) {
 dummyCounter++;
 };
 }
 p.arriveAndAwaitAdvance(); // Phase 2 (blocking)
-System.out.println("LockBThread about to exit");
+log("LockBThread about to exit");
 // Make sure the current thread is not holding any lock
 assertNoLock(this);
 }
 }
 private static WaitingThread waiter;
-private static Object ready = new Object();
+private static final Object ready = new Object();
 private static CheckerThread checker;
 static class WaitingThread extends Thread {
 private final Phaser p;
 volatile boolean waiting = false;
 public WaitingThread(Phaser p) {
 super("WaitingThread");
 this.p = p;
 }
+@Override
 public void run() {
 synchronized(objC) {
-System.out.println("WaitingThread about to wait on objC");
+log("WaitingThread about to wait on objC");
 try {
 // Signal checker thread, about to wait on objC.
 waiting = false;
 p.arriveAndAwaitAdvance(); // Phase 1 (waiting)
 waiting = true;
 e.printStackTrace();
 testFailed = true;
 }
 // block until CheckerThread finishes checking
-System.out.println("WaitingThread about to block on ready");
+log("WaitingThread about to block on ready");
 // signal checker thread that it is about acquire
 // object ready.
 p.arriveAndAwaitAdvance(); // Phase 2 (waiting)
 synchronized(ready) {
 dummyCounter++;
-};
+}
 }
 synchronized(objC) {
 try {
 // signal checker thread, about to wait on objC
 waiting = false;
 } catch (InterruptedException e) {
 e.printStackTrace();
 testFailed = true;
 }
 }
-System.out.println("WaitingThread about to exit waiting on objC 2");
+log("WaitingThread about to exit waiting on objC 2");
 }
 public void waitForWaiting() {
 p.arriveAndAwaitAdvance();
 while (!waiting) {
 }
 private static ThreadInfo findOwnerInfo(ThreadInfo[] infos, String lock)
 throws Exception {
 ThreadInfo ownerInfo = null;
-for (int i = 0; i < infos.length; i++) {
+for (ThreadInfo info : infos) {
-String blockedLock = infos[i].getLockName();
+String blockedLock = info.getLockName();
 if (lock.equals(blockedLock)) {
-long threadId = infos[i].getLockOwnerId();
+long threadId = info.getLockOwnerId();
 if (threadId == -1) {
 throw new RuntimeException("TEST FAILED: " +
 lock + " expected to have owner");
 }
 for (int j = 0; j < infos.length; j++) {
 private static void doCheck(ThreadInfo[] infos, String lock, long[] expectedThreads)
 throws Exception {
 ThreadInfo ownerInfo = null;
 // Find the thread who is blocking on lock
-for (int i = 0; i < infos.length;  i++) {
+for (ThreadInfo info : infos) {
-String blockedLock = infos[i].getLockName();
+String blockedLock = info.getLockName();
 if (lock.equals(blockedLock)) {
-System.out.print(infos[i].getThreadName() +
+log("%s blocked on %s", info.getThreadName(), blockedLock);
-" blocked on " + blockedLock);
+ownerInfo = info;
-ownerInfo = infos[i];
+}
 }
+if (ownerInfo == null) {
+throw new RuntimeException("TEST FAILED: " +
+"Can't retrieve ThreadInfo for the blocked thread");
 }
 long[] threads = new long[10];
 int count = 0;
 threads[count++] = ownerInfo.getThreadId();
 while (ownerInfo != null && ownerInfo.getThreadState() == Thread.State.BLOCKED) {
 ownerInfo = findOwnerInfo(infos, lock);
 threads[count++] = ownerInfo.getThreadId();
-System.out.println(" Owner = " + ownerInfo.getThreadName() +
+log(" Owner = %s  id = %d",
-" id = " + ownerInfo.getThreadId());
+ownerInfo.getThreadName(),
+ownerInfo.getThreadId()
+);
 lock = ownerInfo.getLockName();
-System.out.print(ownerInfo.getThreadName() + " Id = " +
+log("%s Id = %d  blocked on %s",
-ownerInfo.getThreadId() +
+ownerInfo.getThreadName(),
-" blocked on " + lock);
+ownerInfo.getThreadId(),
-}
+lock
-System.out.println();
+);
+}
+log("");
 if (count != expectedThreads.length) {
 throw new RuntimeException("TEST FAILED: " +
 "Expected chain of threads not matched; current count =" + count);
 }
 for (int i = 0; i < count; i++) {
 if (threads[i] != expectedThreads[i]) {
-System.out.println("TEST FAILED: " +
+log("TEST FAILED: Unexpected thread in the chain %s expected to be %s",
-"Unexpected thread in the chain " + threads[i] +
+threads[i],
-" expected to be " + expectedThreads[i]);
+expectedThreads[i]
-}
+);
 }
+}
+}
+private static void log(String format, Object ... args) {
+logger.log(format + "%n", args);
 }
 }

changeset 28101	acc6f4bcb37e
parent 23337	d4a11c730d92
child 30376	2ccf2cf7ea48