test/java/lang/ThreadGroup/Suspend.java

Print this page

        

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2013 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.

@@ -21,49 +21,59 @@
  * questions.
  */
 
 /**
  * @test
- * @bug 4176355
+ * @bug 4176355 7181748
  * @summary Suspending a ThreadGroup that contains the current thread has
  *          unpredictable results.
  */
 
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
 public class Suspend implements Runnable {
-    private static Thread first=null;
-    private static Thread second=null;
-    private static ThreadGroup group = new ThreadGroup("");
-    private static int count = 0;
-
-    Suspend() {
-        Thread thread = new Thread(group, this);
-        if (first == null)
-            first = thread;
-        else
-            second = thread;
 
-        thread.start();
-    }
+    private static final ThreadGroup group = new ThreadGroup("");
+    private static final Thread first = new Thread(group, new Suspend());
+    private static final Thread second = new Thread(group, new Suspend());
+    private static final CountDownLatch groupStarted = new CountDownLatch(2);
+    private static final CountDownLatch runGroup = new CountDownLatch(1);
+    private static final CountDownLatch secondContinue = new CountDownLatch(1);
+    private static final CountDownLatch secondDone = new CountDownLatch(1);
 
     public void run() {
+        groupStarted.countDown();
         while (true) {
             try {
-                Thread.sleep(1000); // Give other thread a chance to start
-                if (Thread.currentThread() == first)
+                runGroup.await();
+                if (Thread.currentThread() == first) {
                     group.suspend();
-                else
-                    count++;
-            } catch(InterruptedException e){
+                } else {
+                    secondContinue.await();
+                    secondDone.countDown(); // should never be executed
+                }
+            } catch (InterruptedException ex) {
             }
         }
     }
 
     public static void main(String[] args) throws Exception {
-        for (int i=0; i<2; i++)
-            new Suspend();
-        Thread.sleep(3000);
-        boolean failed = (count > 1);
-        first.stop(); second.stop();
+        // Launch two threads as part of the same thread group
+        first.start();
+        second.start();
+
+        groupStarted.await();
+        runGroup.countDown();
+        Thread.sleep(1000);
+        // Suppose, the thread group is now suspended
+
+        secondContinue.countDown();
+
+        // Reaching zero count indicates that the second thread is still running
+        boolean failed = secondDone.await(1L, TimeUnit.SECONDS);
+        first.stop();
+        second.stop();
         if (failed)
             throw new RuntimeException("Failure.");
     }
 }