/*

 * 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 {

            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);

        }

        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);

        }

        p.arriveAndAwaitAdvance(); // phase[2]

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

        synchronized(lock2) {

            p.arriveAndAwaitAdvance(); // phase [3]

            waitForThreadState(lt, Thread.State.BLOCKED);

        }

        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;

    }

}