jdk/test/javax/management/monitor/ThreadPoolTest.java
changeset 2 90ce3da70b43
child 5506 202f599c92aa
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/management/monitor/ThreadPoolTest.java	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,238 @@
+/*
+ * Copyright 2005-2006 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 6222826 6379712
+ * @summary Test that all monitors will be well started when sharing
+ * a single thread pool.
+ * @author Luis-Miguel Alventosa
+ * @run clean ThreadPoolTest
+ * @run build ThreadPoolTest
+ * @run main/othervm/timeout=300 ThreadPoolTest 1
+ * @run main/othervm/timeout=300 ThreadPoolTest 2
+ * @run main/othervm/timeout=300 ThreadPoolTest 3
+ * @run main/othervm/timeout=300 -Djmx.x.monitor.maximum.pool.size=5 ThreadPoolTest 1
+ * @run main/othervm/timeout=300 -Djmx.x.monitor.maximum.pool.size=5 ThreadPoolTest 2
+ * @run main/othervm/timeout=300 -Djmx.x.monitor.maximum.pool.size=5 ThreadPoolTest 3
+ * @run main/othervm/timeout=300 -Djmx.x.monitor.maximum.pool.size=-5 ThreadPoolTest 1
+ * @run main/othervm/timeout=300 -Djmx.x.monitor.maximum.pool.size=-5 ThreadPoolTest 2
+ * @run main/othervm/timeout=300 -Djmx.x.monitor.maximum.pool.size=-5 ThreadPoolTest 3
+ */
+
+import java.util.concurrent.atomic.AtomicInteger;
+import javax.management.MBeanServer;
+import javax.management.MBeanServerFactory;
+import javax.management.Notification;
+import javax.management.NotificationListener;
+import javax.management.ObjectName;
+import javax.management.monitor.CounterMonitor;
+import javax.management.monitor.GaugeMonitor;
+import javax.management.monitor.Monitor;
+import javax.management.monitor.MonitorNotification;
+import javax.management.monitor.StringMonitor;
+
+public class ThreadPoolTest {
+
+    static int maxPoolSize;
+    static int nTasks;
+    private static Waiter waiter;
+
+    static final long MAX_WAITING_TIME = 10000;
+
+    // MBean class
+    public class ObservedObject implements ObservedObjectMBean {
+        private boolean called = false;
+        public Integer getInteger() {
+            inform("getInteger()");
+            return 0;
+        }
+        public Double getDouble() {
+            inform("getDouble()");
+            return 0.0;
+        }
+        public String getString() {
+            inform("getString()");
+            return "";
+        }
+        private void inform(String prop) {
+            synchronized(waiter) {
+                if (!called) {
+                    called = true;
+                    waiter.count();
+                }
+            }
+
+            echo(">>> TASK "+prop+" is called.");
+        }
+    }
+
+    // MBean interface
+    public interface ObservedObjectMBean {
+        public Integer getInteger();
+        public Double getDouble();
+        public String getString();
+    }
+
+    /**
+     * Run test
+     */
+    public int runTest(int monitorType) throws Exception {
+
+
+        ObjectName[] mbeanNames = new ObjectName[nTasks];
+        ObservedObject[] monitored = new ObservedObject[nTasks];
+        ObjectName[] monitorNames = new ObjectName[nTasks];
+        Monitor[] monitor = new Monitor[nTasks];
+        String[] attributes = { "Integer", "Double", "String" };
+
+        try {
+            echo(">>> CREATE MBeanServer");
+            MBeanServer server = MBeanServerFactory.newMBeanServer();
+
+            String domain = server.getDefaultDomain();
+
+            for (int i = 0; i < nTasks; i++) {
+                mbeanNames[i] =
+                    new ObjectName(":type=ObservedObject,instance=" + (i + 1));
+                monitored[i] = new ObservedObject();
+                echo(">>> CREATE ObservedObject = " + mbeanNames[i].toString());
+                server.registerMBean(monitored[i], mbeanNames[i]);
+                switch (monitorType) {
+                case 1:
+                    monitorNames[i] = new ObjectName(":type=CounterMonitor," +
+                                                     "instance=" + (i + 1));
+                    monitor[i] = new CounterMonitor();
+                    break;
+                case 2:
+                    monitorNames[i] = new ObjectName(":type=GaugeMonitor," +
+                                                     "instance=" + (i + 1));
+                    monitor[i] = new GaugeMonitor();
+                    break;
+                case 3:
+                    monitorNames[i] = new ObjectName(":type=StringMonitor," +
+                                                     "instance=" + (i + 1));
+                    monitor[i] = new StringMonitor();
+                    break;
+                default:
+                    echo("Unsupported monitor type");
+                    return 1;
+                }
+                echo(">>> CREATE Monitor = " + monitorNames[i].toString());
+                server.registerMBean(monitor[i], monitorNames[i]);
+                monitor[i].addObservedObject(mbeanNames[i]);
+                monitor[i].setObservedAttribute(attributes[monitorType-1]);
+                monitor[i].setGranularityPeriod(50);
+                monitor[i].start();
+            }
+
+            if (!waiter.waiting(MAX_WAITING_TIME)) {
+                echo("Error, not all "+nTasks+" monitor tasks are called after "
+                     +MAX_WAITING_TIME);
+                return 1;
+            }
+        } finally {
+            for (int i = 0; i < nTasks; i++)
+                if (monitor[i] != null)
+                    monitor[i].stop();
+        }
+
+        echo("All "+nTasks+" monitors are called.");
+        return 0;
+    }
+
+    /*
+     * Print message
+     */
+    private static void echo(String message) {
+        System.out.println(message);
+    }
+
+    /*
+     * Standalone entry point.
+     *
+     * Run the test and report to stdout.
+     */
+    public static void main (String args[]) throws Exception {
+        Integer size = Integer.getInteger("jmx.x.monitor.maximum.pool.size");
+        if (size == null) {
+            maxPoolSize = 10;
+            echo(">>> MAXIMUM POOL SIZE = 10 [default value]");
+        } else {
+            maxPoolSize = size.intValue() < 1 ? 1 : size.intValue();
+            echo(">>> MAXIMUM POOL SIZE = " + maxPoolSize);
+        }
+
+        nTasks = maxPoolSize + 2;
+        waiter = new Waiter(nTasks);
+        ThreadPoolTest test = new ThreadPoolTest();
+
+        int error = test.runTest(Integer.parseInt(args[0]));
+        if (error > 0) {
+            echo(">>> Unhappy Bye, Bye!");
+            throw new IllegalStateException(
+                "Test FAILED: Unexpected Maximum Pool Size Overflow!");
+        } else {
+            echo(">>> Happy Bye, Bye!");
+        }
+    }
+
+    private static class Waiter {
+        public Waiter(int waitedNB) {
+            this.waitedNB = waitedNB;
+        }
+
+        public void count() {
+            synchronized(this) {
+                counted++;
+
+                if (counted == waitedNB) {
+                    this.notifyAll();
+                }
+            }
+        }
+
+        public boolean waiting(long timeout) {
+            final long startTime = System.currentTimeMillis();
+            long toWait = timeout;
+
+            synchronized(this) {
+                while(counted < waitedNB && toWait > 0) {
+                    try {
+                        this.wait(toWait);
+                    } catch (InterruptedException ire) {
+                        break;
+                    }
+
+                    toWait = timeout -
+                        (System.currentTimeMillis() - startTime);
+                }
+            }
+
+            return counted == waitedNB;
+        }
+
+        private int waitedNB;
+        private int counted = 0;
+    }
+}