SynchronizationStatistics.java

/*
 * 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
 *
 * @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;
    }
}