--- /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;
+ }
+}