jdk/test/java/lang/management/ThreadMXBean/SynchronizationStatistics.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2003, 2015, 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     4530538
  * @summary Basic unit test of the synchronization statistics support:
  *
  * @author  Mandy Chung
  * @author  Jaroslav Bachorik
  *
  * @modules java.management
  * @run main/othervm SynchronizationStatistics
  */

 import java.lang.management.*;
 import java.util.concurrent.Phaser;
 import java.util.function.Supplier;

 public class SynchronizationStatistics {
     private static class LockerThread extends Thread {
         public LockerThread(Runnable r) {
             super(r, "LockerThread");
         }
     }

     private static final ThreadMXBean mbean = ManagementFactory.getThreadMXBean();

     private static final boolean blockedTimeCheck =
         mbean.isThreadContentionMonitoringSupported();


     public static void main(String args[]) throws Exception {
         if (blockedTimeCheck) {
             mbean.setThreadContentionMonitoringEnabled(true);
         }

         if (!mbean.isThreadContentionMonitoringEnabled()) {
             throw new RuntimeException("TEST FAILED: " +
                 "Thread Contention Monitoring is not enabled");
         }

         testBlockingOnSimpleMonitor();
         testBlockingOnNestedMonitor();
         testWaitingOnSimpleMonitor();
         testMultiWaitingOnSimpleMonitor();
         testWaitingOnNestedMonitor();

         System.out.println("Test passed.");
     }

     private static LockerThread newLockerThread(Runnable r) {
         LockerThread t = new LockerThread(r);
         t.setDaemon(true);
         return t;
     }

     private static void waitForThreadState(Thread t, Thread.State state) throws InterruptedException {
         while (t.getState() != state) {
             Thread.sleep(3);
         }
     }

     /**
      * Tests that blocking on a single monitor properly increases the
      * blocked count at least by 1. Also asserts that the correct lock name is provided.
      */
     private static void testBlockingOnSimpleMonitor() throws Exception {
         System.out.println("testBlockingOnSimpleMonitor");
         final Object lock1 = new Object();
         System.out.println("Lock1 = " + lock1);

         final Phaser p = new Phaser(2);
         LockerThread lt = newLockerThread(new Runnable() {
             @Override
             public void run() {
                 p.arriveAndAwaitAdvance(); // phase[1]
                 synchronized(lock1) {
                     System.out.println("[LockerThread obtained Lock1]");
                     p.arriveAndAwaitAdvance(); // phase[2]
                 }
                 p.arriveAndAwaitAdvance(); // phase[3]
             }
         });

         lt.start();
         long tid = lt.getId();
         ThreadInfo ti = mbean.getThreadInfo(tid);
         String lockName = null;
         synchronized(lock1) {
             p.arriveAndAwaitAdvance(); // phase[1]
             waitForThreadState(lt, Thread.State.BLOCKED);
             do {
                 lockName = mbean.getThreadInfo(tid).getLockName();
             } while (lockName == null);
         }

         p.arriveAndAwaitAdvance(); // phase[2]
         testBlocked(ti, () -> mbean.getThreadInfo(tid), lockName, lock1);
         p.arriveAndDeregister(); // phase[3]

         lt.join();

         printok();
     }

     /**
      * Tests that blocking on a nested monitor properly increases the
      * blocked count at least by 1 - it is not affected by the nesting depth.
      * Also asserts that the correct lock name is provided.
      */
     private static void testBlockingOnNestedMonitor() throws Exception {
         System.out.println("testBlockingOnNestedMonitor");
         final Object lock1 = new Object();
         final Object lock2 = new Object();

         System.out.println("Lock1 = " + lock1);
         System.out.println("Lock2 = " + lock2);

         final Phaser p = new Phaser(2);
         LockerThread lt = newLockerThread(new Runnable() {
             @Override
             public void run() {
                 p.arriveAndAwaitAdvance(); // phase[1]
                 synchronized(lock1) {
                     System.out.println("[LockerThread obtained Lock1]");
                     p.arriveAndAwaitAdvance(); // phase[2]
                     p.arriveAndAwaitAdvance(); // phase[3]
                     synchronized(lock2) {
                         System.out.println("[LockerThread obtained Lock2]");
                         p.arriveAndAwaitAdvance(); // phase[4]
                     }
                     p.arriveAndAwaitAdvance(); // phase[5]
                 }
             }
         });

         lt.start();
         long tid = lt.getId();
         ThreadInfo ti = mbean.getThreadInfo(tid);
         String lockName = null;
         synchronized(lock1) {
             p.arriveAndAwaitAdvance(); // phase[1]
             waitForThreadState(lt, Thread.State.BLOCKED);
             do {
                 lockName = mbean.getThreadInfo(tid).getLockName();
             } while (lockName == null);
         }
         p.arriveAndAwaitAdvance(); // phase[2]

         ti = testBlocked(ti, () -> mbean.getThreadInfo(tid), lockName, lock1);

         synchronized(lock2) {
             p.arriveAndAwaitAdvance(); // phase [3]
             waitForThreadState(lt, Thread.State.BLOCKED);
             do {
                 lockName = mbean.getThreadInfo(tid).getLockName();
             } while (lockName == null);
         }
         p.arriveAndAwaitAdvance(); // phase [4]
         testBlocked(ti, () -> mbean.getThreadInfo(tid), lockName, lock2);
         p.arriveAndDeregister();

         lt.join();

         printok();
     }

     /**
      * Tests that waiting on a single monitor properly increases the waited
      * count by 1 and the waited time by a positive number.
      */
     private static void testWaitingOnSimpleMonitor() throws Exception {
         System.out.println("testWaitingOnSimpleMonitor");
         final Object lock1 = new Object();
         final Phaser p = new Phaser(2);
         LockerThread lt = newLockerThread(new Runnable() {
             @Override
             public void run() {
                 p.arriveAndAwaitAdvance(); // phase[1]
                 synchronized(lock1) {
                     System.out.println("[LockerThread obtained Lock1]");
                     try {
                         lock1.wait(300);
                     } catch (InterruptedException ex) {
                         // ignore
                     }
                     p.arriveAndAwaitAdvance(); // phase[2]
                 }
                 p.arriveAndAwaitAdvance(); // phase[3]
             }
         });

         lt.start();
         ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
         synchronized(lock1) {
             p.arriveAndAwaitAdvance(); // phase[1]
             waitForThreadState(lt, Thread.State.BLOCKED);
         }
         p.arriveAndAwaitAdvance(); // phase[2]

         testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 1);
         p.arriveAndDeregister(); // phase[3]

         lt.join();

         printok();
     }

     /**
      * Tests that waiting multiple times on the same monitor subsequently
      * increases the waited count by the number of subsequent calls and the
      * waited time by a positive number.
      */
     private static void testMultiWaitingOnSimpleMonitor() throws Exception {
         System.out.println("testWaitingOnMultipleMonitors");
         final Object lock1 = new Object();

         final Phaser p = new Phaser(2);
         LockerThread lt = newLockerThread(new Runnable() {
             @Override
             public void run() {
                 p.arriveAndAwaitAdvance(); // phase[1]
                 synchronized(lock1) {
                     System.out.println("[LockerThread obtained Lock1]");
                     for (int i = 0; i < 3; i++) {
                         try {
                             lock1.wait(300);
                         } catch (InterruptedException ex) {
                             // ignore
                         }
                         p.arriveAndAwaitAdvance(); // phase[2-4]
                     }
                 }
                 p.arriveAndAwaitAdvance(); // phase[5]
             }
         });

         lt.start();
         ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
         synchronized(lock1) {
             p.arriveAndAwaitAdvance(); //phase[1]
             waitForThreadState(lt, Thread.State.BLOCKED);
         }
         int phase = p.getPhase();
         while ((p.arriveAndAwaitAdvance() - phase) < 3); // phase[2-4]

         testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 3);
         p.arriveAndDeregister(); // phase[5]

         lt.join();

         printok();
     }

     /**
      * Tests that waiting on monitors places in nested synchronized blocks
      * properly increases the waited count by the number of times the "lock.wait()"
      * was invoked and the waited time by a positive number.
      */
     private static void testWaitingOnNestedMonitor() throws Exception {
         System.out.println("testWaitingOnNestedMonitor");
         final Object lock1 = new Object();
         final Object lock2 = new Object();
         final Object lock3 = new Object();

         final Phaser p = new Phaser(2);
         LockerThread lt = newLockerThread(new Runnable() {
             @Override
             public void run() {
                 p.arriveAndAwaitAdvance(); // phase[1]
                 synchronized(lock1) {
                     System.out.println("[LockerThread obtained Lock1]");
                     try {
                         lock1.wait(300);
                     } catch (InterruptedException ex) {
                         // ignore
                     }

                     p.arriveAndAwaitAdvance(); // phase[2]
                     synchronized(lock2) {
                         System.out.println("[LockerThread obtained Lock2]");
                         try {
                             lock2.wait(300);
                         } catch (InterruptedException ex) {
                             // ignore
                         }

                         p.arriveAndAwaitAdvance(); // phase[3]
                         synchronized(lock3) {
                             System.out.println("[LockerThread obtained Lock3]");
                             try {
                                 lock3.wait(300);
                             } catch (InterruptedException ex) {
                                 // ignore
                             }
                             p.arriveAndAwaitAdvance(); // phase[4]
                         }
                     }
                 }
                 p.arriveAndAwaitAdvance(); // phase[5]
             }
         });

         lt.start();
         ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
         synchronized(lock1) {
             p.arriveAndAwaitAdvance(); // phase[1]
             waitForThreadState(lt, Thread.State.BLOCKED);
         }

         synchronized(lock2) {
             p.arriveAndAwaitAdvance(); // phase[2]
             waitForThreadState(lt, Thread.State.BLOCKED);
         }

         synchronized(lock3) {
             p.arriveAndAwaitAdvance(); // phase[3]
             waitForThreadState(lt, Thread.State.BLOCKED);
         }

         p.arriveAndAwaitAdvance(); // phase[4]
         testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 3);
         p.arriveAndDeregister(); // phase[5]

         lt.join();
         printok();
     }

     private static void printok() {
         System.out.println("OK\n");
     }

     private static void testWaited(ThreadInfo ti1, Supplier<ThreadInfo> ti2, int waited)
     throws InterruptedException {
         boolean error;
         do {
             error = false;
             ThreadInfo ti = ti2.get();
             long waitCntDiff = ti.getWaitedCount() - ti1.getWaitedCount();
             long waitTimeDiff = ti.getWaitedTime() - ti1.getWaitedTime();
             if (waitCntDiff < waited) {
                 System.err.println(
                     "Unexpected diff in waited count. Expecting at least "
                     + waited + " , got " + waitCntDiff
                 );
                 error = true;
             }
             if (waitTimeDiff <= 0) {
                 System.err.println(
                     "Unexpected diff in waited time. Expecting increasing " +
                     "value, got " + waitTimeDiff + "ms"
                 );
                 error = true;
             }
             if (error) {
                 System.err.println("Retrying in 20ms ...");
                 Thread.sleep(20);
             }
         } while (error);
     }

     private static ThreadInfo testBlocked(ThreadInfo ti1, Supplier<ThreadInfo> ti2,
                                     String lockName, final Object lock)
     throws InterruptedException {
         boolean error;
         ThreadInfo ti = null;
         do {
             error = false;
             ti = ti2.get();
             long blkCntDiff = ti.getBlockedCount() - ti1.getBlockedCount();
             long blkTimeDiff = ti.getBlockedTime() - ti1.getBlockedTime();

             System.out.println("testBlocked: [" + blkCntDiff + ", " + blkTimeDiff + ", " + lockName + "]");

             if (blkCntDiff < 1) {
                 System.err.println(
                     "Unexpected diff in blocked count. Expecting at least 1, " +
                     "got " + blkCntDiff
                 );
                 error = true;
             }
             if (blkTimeDiff < 0) {
                 System.err.println(
                     "Unexpected diff in blocked time. Expecting a positive " +
                     "number, got " + blkTimeDiff
                 );
                 error = true;
             }
             if (!lockName.equals(lock.toString())) {
                 System.err.println(
                     "Unexpected blocked monitor name. Expecting " +
                     lock.toString() + ", got " + lockName
                 );
                 error = true;
             }
             if (error) {
                 System.err.println("Retrying in 20ms ...");
                 Thread.sleep(20);
             }
         } while (error);
         return ti;
     }
 }
	/*
	* Copyright (c) 2003, 2015, 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 4530538
	* @summary Basic unit test of the synchronization statistics support:
	*
	* @author Mandy Chung
	* @author Jaroslav Bachorik
	*
	* @modules java.management
	* @run main/othervm SynchronizationStatistics
	*/

	import java.lang.management.*;
	import java.util.concurrent.Phaser;
	import java.util.function.Supplier;

	public class SynchronizationStatistics {
	private static class LockerThread extends Thread {
	public LockerThread(Runnable r) {
	super(r, "LockerThread");
	}
	}

	private static final ThreadMXBean mbean = ManagementFactory.getThreadMXBean();

	private static final boolean blockedTimeCheck =
	mbean.isThreadContentionMonitoringSupported();


	public static void main(String args[]) throws Exception {
	if (blockedTimeCheck) {
	mbean.setThreadContentionMonitoringEnabled(true);
	}

	if (!mbean.isThreadContentionMonitoringEnabled()) {
	throw new RuntimeException("TEST FAILED: " +
	"Thread Contention Monitoring is not enabled");
	}

	testBlockingOnSimpleMonitor();
	testBlockingOnNestedMonitor();
	testWaitingOnSimpleMonitor();
	testMultiWaitingOnSimpleMonitor();
	testWaitingOnNestedMonitor();

	System.out.println("Test passed.");
	}

	private static LockerThread newLockerThread(Runnable r) {
	LockerThread t = new LockerThread(r);
	t.setDaemon(true);
	return t;
	}

	private static void waitForThreadState(Thread t, Thread.State state) throws InterruptedException {
	while (t.getState() != state) {
	Thread.sleep(3);
	}
	}

	/**
	* Tests that blocking on a single monitor properly increases the
	* blocked count at least by 1. Also asserts that the correct lock name is provided.
	*/
	private static void testBlockingOnSimpleMonitor() throws Exception {
	System.out.println("testBlockingOnSimpleMonitor");
	final Object lock1 = new Object();
	System.out.println("Lock1 = " + lock1);

	final Phaser p = new Phaser(2);
	LockerThread lt = newLockerThread(new Runnable() {
	@Override
	public void run() {
	p.arriveAndAwaitAdvance(); // phase[1]
	synchronized(lock1) {
	System.out.println("[LockerThread obtained Lock1]");
	p.arriveAndAwaitAdvance(); // phase[2]
	}
	p.arriveAndAwaitAdvance(); // phase[3]
	}
	});

	lt.start();
	long tid = lt.getId();
	ThreadInfo ti = mbean.getThreadInfo(tid);
	String lockName = null;
	synchronized(lock1) {
	p.arriveAndAwaitAdvance(); // phase[1]
	waitForThreadState(lt, Thread.State.BLOCKED);
	do {
	lockName = mbean.getThreadInfo(tid).getLockName();
	} while (lockName == null);
	}

	p.arriveAndAwaitAdvance(); // phase[2]
	testBlocked(ti, () -> mbean.getThreadInfo(tid), lockName, lock1);
	p.arriveAndDeregister(); // phase[3]

	lt.join();

	printok();
	}

	/**
	* Tests that blocking on a nested monitor properly increases the
	* blocked count at least by 1 - it is not affected by the nesting depth.
	* Also asserts that the correct lock name is provided.
	*/
	private static void testBlockingOnNestedMonitor() throws Exception {
	System.out.println("testBlockingOnNestedMonitor");
	final Object lock1 = new Object();
	final Object lock2 = new Object();

	System.out.println("Lock1 = " + lock1);
	System.out.println("Lock2 = " + lock2);

	final Phaser p = new Phaser(2);
	LockerThread lt = newLockerThread(new Runnable() {
	@Override
	public void run() {
	p.arriveAndAwaitAdvance(); // phase[1]
	synchronized(lock1) {
	System.out.println("[LockerThread obtained Lock1]");
	p.arriveAndAwaitAdvance(); // phase[2]
	p.arriveAndAwaitAdvance(); // phase[3]
	synchronized(lock2) {
	System.out.println("[LockerThread obtained Lock2]");
	p.arriveAndAwaitAdvance(); // phase[4]
	}
	p.arriveAndAwaitAdvance(); // phase[5]
	}
	}
	});

	lt.start();
	long tid = lt.getId();
	ThreadInfo ti = mbean.getThreadInfo(tid);
	String lockName = null;
	synchronized(lock1) {
	p.arriveAndAwaitAdvance(); // phase[1]
	waitForThreadState(lt, Thread.State.BLOCKED);
	do {
	lockName = mbean.getThreadInfo(tid).getLockName();
	} while (lockName == null);
	}
	p.arriveAndAwaitAdvance(); // phase[2]

	ti = testBlocked(ti, () -> mbean.getThreadInfo(tid), lockName, lock1);

	synchronized(lock2) {
	p.arriveAndAwaitAdvance(); // phase [3]
	waitForThreadState(lt, Thread.State.BLOCKED);
	do {
	lockName = mbean.getThreadInfo(tid).getLockName();
	} while (lockName == null);
	}
	p.arriveAndAwaitAdvance(); // phase [4]
	testBlocked(ti, () -> mbean.getThreadInfo(tid), lockName, lock2);
	p.arriveAndDeregister();

	lt.join();

	printok();
	}

	/**
	* Tests that waiting on a single monitor properly increases the waited
	* count by 1 and the waited time by a positive number.
	*/
	private static void testWaitingOnSimpleMonitor() throws Exception {
	System.out.println("testWaitingOnSimpleMonitor");
	final Object lock1 = new Object();
	final Phaser p = new Phaser(2);
	LockerThread lt = newLockerThread(new Runnable() {
	@Override
	public void run() {
	p.arriveAndAwaitAdvance(); // phase[1]
	synchronized(lock1) {
	System.out.println("[LockerThread obtained Lock1]");
	try {
	lock1.wait(300);
	} catch (InterruptedException ex) {
	// ignore
	}
	p.arriveAndAwaitAdvance(); // phase[2]
	}
	p.arriveAndAwaitAdvance(); // phase[3]
	}
	});

	lt.start();
	ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
	synchronized(lock1) {
	p.arriveAndAwaitAdvance(); // phase[1]
	waitForThreadState(lt, Thread.State.BLOCKED);
	}
	p.arriveAndAwaitAdvance(); // phase[2]

	testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 1);
	p.arriveAndDeregister(); // phase[3]

	lt.join();

	printok();
	}

	/**
	* Tests that waiting multiple times on the same monitor subsequently
	* increases the waited count by the number of subsequent calls and the
	* waited time by a positive number.
	*/
	private static void testMultiWaitingOnSimpleMonitor() throws Exception {
	System.out.println("testWaitingOnMultipleMonitors");
	final Object lock1 = new Object();

	final Phaser p = new Phaser(2);
	LockerThread lt = newLockerThread(new Runnable() {
	@Override
	public void run() {
	p.arriveAndAwaitAdvance(); // phase[1]
	synchronized(lock1) {
	System.out.println("[LockerThread obtained Lock1]");
	for (int i = 0; i < 3; i++) {
	try {
	lock1.wait(300);
	} catch (InterruptedException ex) {
	// ignore
	}
	p.arriveAndAwaitAdvance(); // phase[2-4]
	}
	}
	p.arriveAndAwaitAdvance(); // phase[5]
	}
	});

	lt.start();
	ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
	synchronized(lock1) {
	p.arriveAndAwaitAdvance(); //phase[1]
	waitForThreadState(lt, Thread.State.BLOCKED);
	}
	int phase = p.getPhase();
	while ((p.arriveAndAwaitAdvance() - phase) < 3); // phase[2-4]

	testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 3);
	p.arriveAndDeregister(); // phase[5]

	lt.join();

	printok();
	}

	/**
	* Tests that waiting on monitors places in nested synchronized blocks
	* properly increases the waited count by the number of times the "lock.wait()"
	* was invoked and the waited time by a positive number.
	*/
	private static void testWaitingOnNestedMonitor() throws Exception {
	System.out.println("testWaitingOnNestedMonitor");
	final Object lock1 = new Object();
	final Object lock2 = new Object();
	final Object lock3 = new Object();

	final Phaser p = new Phaser(2);
	LockerThread lt = newLockerThread(new Runnable() {
	@Override
	public void run() {
	p.arriveAndAwaitAdvance(); // phase[1]
	synchronized(lock1) {
	System.out.println("[LockerThread obtained Lock1]");
	try {
	lock1.wait(300);
	} catch (InterruptedException ex) {
	// ignore
	}

	p.arriveAndAwaitAdvance(); // phase[2]
	synchronized(lock2) {
	System.out.println("[LockerThread obtained Lock2]");
	try {
	lock2.wait(300);
	} catch (InterruptedException ex) {
	// ignore
	}

	p.arriveAndAwaitAdvance(); // phase[3]
	synchronized(lock3) {
	System.out.println("[LockerThread obtained Lock3]");
	try {
	lock3.wait(300);
	} catch (InterruptedException ex) {
	// ignore
	}
	p.arriveAndAwaitAdvance(); // phase[4]
	}
	}
	}
	p.arriveAndAwaitAdvance(); // phase[5]
	}
	});

	lt.start();
	ThreadInfo ti1 = mbean.getThreadInfo(lt.getId());
	synchronized(lock1) {
	p.arriveAndAwaitAdvance(); // phase[1]
	waitForThreadState(lt, Thread.State.BLOCKED);
	}

	synchronized(lock2) {
	p.arriveAndAwaitAdvance(); // phase[2]
	waitForThreadState(lt, Thread.State.BLOCKED);
	}

	synchronized(lock3) {
	p.arriveAndAwaitAdvance(); // phase[3]
	waitForThreadState(lt, Thread.State.BLOCKED);
	}

	p.arriveAndAwaitAdvance(); // phase[4]
	testWaited(ti1, () -> mbean.getThreadInfo(lt.getId()), 3);
	p.arriveAndDeregister(); // phase[5]

	lt.join();
	printok();
	}

	private static void printok() {
	System.out.println("OK\n");
	}

	private static void testWaited(ThreadInfo ti1, Supplier<ThreadInfo> ti2, int waited)
	throws InterruptedException {
	boolean error;
	do {
	error = false;
	ThreadInfo ti = ti2.get();
	long waitCntDiff = ti.getWaitedCount() - ti1.getWaitedCount();
	long waitTimeDiff = ti.getWaitedTime() - ti1.getWaitedTime();
	if (waitCntDiff < waited) {
	System.err.println(
	"Unexpected diff in waited count. Expecting at least "
	+ waited + " , got " + waitCntDiff
	);
	error = true;
	}
	if (waitTimeDiff <= 0) {
	System.err.println(
	"Unexpected diff in waited time. Expecting increasing " +
	"value, got " + waitTimeDiff + "ms"
	);
	error = true;
	}
	if (error) {
	System.err.println("Retrying in 20ms ...");
	Thread.sleep(20);
	}
	} while (error);
	}

	private static ThreadInfo testBlocked(ThreadInfo ti1, Supplier<ThreadInfo> ti2,
	String lockName, final Object lock)
	throws InterruptedException {
	boolean error;
	ThreadInfo ti = null;
	do {
	error = false;
	ti = ti2.get();
	long blkCntDiff = ti.getBlockedCount() - ti1.getBlockedCount();
	long blkTimeDiff = ti.getBlockedTime() - ti1.getBlockedTime();

	System.out.println("testBlocked: [" + blkCntDiff + ", " + blkTimeDiff + ", " + lockName + "]");

	if (blkCntDiff < 1) {
	System.err.println(
	"Unexpected diff in blocked count. Expecting at least 1, " +
	"got " + blkCntDiff
	);
	error = true;
	}
	if (blkTimeDiff < 0) {
	System.err.println(
	"Unexpected diff in blocked time. Expecting a positive " +
	"number, got " + blkTimeDiff
	);
	error = true;
	}
	if (!lockName.equals(lock.toString())) {
	System.err.println(
	"Unexpected blocked monitor name. Expecting " +
	lock.toString() + ", got " + lockName
	);
	error = true;
	}
	if (error) {
	System.err.println("Retrying in 20ms ...");
	Thread.sleep(20);
	}
	} while (error);
	return ti;
	}
	}