test/java/lang/ThreadGroup/Suspend.java

*** 1,7 ****
  /*
!  * Copyright (c) 1999, 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.
--- 1,7 ----
  /*
!  * 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,69 ****
   * questions.
   */
  
  /**
   * @test
!  * @bug 4176355
   * @summary Suspending a ThreadGroup that contains the current thread has
   *          unpredictable results.
   */
  
  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();
!     }
  
      public void run() {
          while (true) {
              try {
!                 Thread.sleep(1000); // Give other thread a chance to start
!                 if (Thread.currentThread() == first)
                      group.suspend();
!                 else
!                     count++;
!             } catch(InterruptedException e){
              }
          }
      }
  
      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();
          if (failed)
              throw new RuntimeException("Failure.");
      }
  }
--- 21,79 ----
   * questions.
   */
  
  /**
   * @test
!  * @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 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 {
!                 runGroup.await();
!                 if (Thread.currentThread() == first) {
                      group.suspend();
!                 } else {
!                     secondContinue.await();
!                     secondDone.countDown(); // should never be executed
!                 }
!             } catch (InterruptedException ex) {
              }
          }
      }
  
      public static void main(String[] args) throws Exception {
!         // 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.");
      }
  }