6543856: MonitorVmStartTerminate.sh fails intermittently

Reviewed-by: sla, dholmes

test/sun/jvmstat/monitor/MonitoredVm/MonitorVmStartTerminate.java

@@ -21,6 +21,7 @@
  * questions.
  */
 
+import java.util.concurrent.CountDownLatch;
 import java.util.regex.*;
 import java.util.*;
 import java.net.URISyntaxException;
@@ -33,8 +34,6 @@ public class MonitorVmStartTerminate {
     private static final int SLEEPERS = 10;
     private static final int SLEEPTIME = 5000;     // sleep time for a sleeper
     private static final int EXECINTERVAL = 3000;   // wait time between exec's
-    private static final int JOINTIME = (SLEEPERS * EXECINTERVAL)
-                                        + SLEEPTIME * 2;
 
     public static void main(String args[]) throws Exception {
 
@@ -46,7 +45,8 @@ public class MonitorVmStartTerminate {
         MonitoredHost host = MonitoredHost.getMonitoredHost("localhost");
         host.setInterval(200);
 
-        SleeperListener listener = new SleeperListener(host, sleeperPattern);
+        Matcher matcher = Pattern.compile(sleeperPattern).matcher("");
+        SleeperListener listener = new SleeperListener(host, matcher, SLEEPERS);
         host.addHostListener(listener);
 
         SleeperStarter ss = new SleeperStarter(SLEEPERS, EXECINTERVAL,
@@ -56,47 +56,40 @@ public class MonitorVmStartTerminate {
         System.out.println("Waiting for "
                            + SLEEPERS + " sleepers to terminate");
         try {
-            ss.join(JOINTIME);
+            ss.join();
         } catch (InterruptedException e) {
-            System.err.println("Timed out waiting for sleepers");
+            throw new Exception("Timed out waiting for sleepers");
         }
-
-        if (listener.getStarted() != SLEEPERS) {
-            throw new RuntimeException(
-                    "Too few sleepers started: "
-                    + " started = " + listener.getStarted()
-                    + " SLEEPERS = " + SLEEPERS);
-        }
-
-        if (listener.getStarted() != listener.getTerminated()) {
-            throw new RuntimeException(
-                    "Started count != terminated count: "
-                    + " started = " + listener.getStarted()
-                    + " terminated = " + listener.getTerminated());
+        listener.waitForSleepersToStart();
+        listener.waitForSleepersToTerminate();
     }
-    }
-}
 
-class SleeperListener implements HostListener {
-    private static final boolean DEBUG = false;
+    public static class SleeperListener implements HostListener {
 
-    int started;
-    int terminated;
-    MonitoredHost host;
-    Matcher patternMatcher;
-    ArrayList targets;
+        private final List<Integer> targets =  new ArrayList<>();
+        private final CountDownLatch terminateLatch;
+        private final CountDownLatch startLatch;
+        private final MonitoredHost host;
+        private final Matcher patternMatcher;
 
-    public SleeperListener(MonitoredHost host, String sleeperPattern) {
+        public SleeperListener(MonitoredHost host, Matcher matcher, int count) {
             this.host = host;
-        Pattern pattern = Pattern.compile(sleeperPattern);
-        patternMatcher = pattern.matcher("");
-        targets = new ArrayList();
+            this.patternMatcher = matcher;
+            this.terminateLatch = new CountDownLatch(count);
+            this.startLatch = new CountDownLatch(count);
         }
 
-    private void printList(Iterator i, String msg) {
+        public void waitForSleepersToTerminate() throws InterruptedException {
+            terminateLatch.await();
+        }
+
+        public void waitForSleepersToStart() throws InterruptedException {
+            startLatch.await();
+        }
+
+        private void printList(Set<Integer> list, String msg) {
             System.out.println(msg + ":");
-        while (i.hasNext()) {
-            Integer lvmid = (Integer)i.next();
+            for (Integer lvmid : list) {
                 try {
                     VmIdentifier vmid = new VmIdentifier("//" + lvmid.intValue());
                     MonitoredVm target = host.getMonitoredVm(vmid);
@@ -119,11 +112,10 @@ class SleeperListener implements HostListener {
         }
 
 
-    private int addStarted(Iterator i) {
+        private int addStarted(Set<Integer> started) {
             int found = 0;
-        while (i.hasNext()) {
+            for (Integer lvmid : started) {
                 try {
-                Integer lvmid = (Integer)i.next();
                     VmIdentifier vmid = new VmIdentifier("//" + lvmid.intValue());
                     MonitoredVm target = host.getMonitoredVm(vmid);
 
@@ -154,10 +146,9 @@ class SleeperListener implements HostListener {
             return found;
         }
 
-    private int removeTerminated(Iterator i) {
+        private int removeTerminated(Set<Integer> terminated) {
             int found = 0;
-        while (i.hasNext()) {
-            Integer lvmid = (Integer)i.next();
+            for (Integer lvmid : terminated) {
                 /*
                  * we don't attempt to attach to the target here as it's
                  * now dead and has no jvmstat share memory file. Just see
@@ -178,40 +169,32 @@ class SleeperListener implements HostListener {
             return found;
         }
 
-    public synchronized int getStarted() {
-        return started;
-    }
-
-    public synchronized int getTerminated() {
-        return terminated;
-    }
-
+        @SuppressWarnings("unchecked")
         public void vmStatusChanged(VmStatusChangeEvent ev) {
-        if (DEBUG) {
-            printList(ev.getActive().iterator(), "Active");
-            printList(ev.getStarted().iterator(), "Started");
-            printList(ev.getTerminated().iterator(), "Terminated");
-        }
+            printList(ev.getActive(), "Active");
+            printList(ev.getStarted(), "Started");
+            printList(ev.getTerminated(), "Terminated");
 
-        int recentlyStarted = addStarted(ev.getStarted().iterator());
-        int recentlyTerminated = removeTerminated(
-                ev.getTerminated().iterator());
+            int recentlyStarted = addStarted(ev.getStarted());
+            int recentlyTerminated = removeTerminated(ev.getTerminated());
 
-        synchronized (this) {
-            started += recentlyStarted;
-            terminated += recentlyTerminated;
+            for (int i = 0; i < recentlyTerminated; i++) {
+                terminateLatch.countDown();
+            }
+            for (int i = 0; i < recentlyStarted; i++) {
+                startLatch.countDown();
             }
         }
 
         public void disconnected(HostEvent ev) {
         }
-}
+    }
 
-class SleeperStarter extends Thread {
+    public static class SleeperStarter extends Thread {
 
-    JavaProcess[] processes;
-    int execInterval;
-    String args;
+        private final JavaProcess[] processes;
+        private final int execInterval;
+        private final String args;
 
         public SleeperStarter(int sleepers, int execInterval, String args) {
             this.execInterval = execInterval;
@@ -221,9 +204,9 @@ class SleeperStarter extends Thread {
 
         private synchronized int active() {
             int active = processes.length;
-        for(int i = 0; i < processes.length; i++) {
+            for(JavaProcess jp : processes) {
                 try {
-                int exitValue = processes[i].exitValue();
+                    jp.exitValue();
                     active--;
                 } catch (IllegalThreadStateException e) {
                     // process hasn't exited yet
@@ -259,9 +242,7 @@ class SleeperStarter extends Thread {
 
            // spin waiting for the processes to terminate
            while (active() > 0) ;
-
-       // give final termination event a change to propogate to
-       // the HostListener
-       try { Thread.sleep(2000); } catch (InterruptedException ignore) { }
+        }
     }
 }
+

test/sun/jvmstat/monitor/MonitoredVm/MonitorVmStartTerminate.sh

@@ -23,7 +23,6 @@
 
 #
 # @test
-# @ignore until 6543856 is fixed
 # @bug 4990825
 # @summary attach to external but local JVM processes
 # @library ../../testlibrary

test/sun/jvmstat/testlibrary/JavaProcess.java

@@ -26,7 +26,6 @@
  */
 
 import java.io.*;
-import java.util.Properties;
 
 public class JavaProcess {