libjava/classpath/java/lang/ThreadGroup.java

   1 /* ThreadGroup -- a group of Threads
   2    Copyright (C) 1998, 2000, 2001, 2002, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package java.lang;
  39
  40 import java.lang.Thread.UncaughtExceptionHandler;
  41 import java.util.Vector;
  42
  43 /**
  44  * ThreadGroup allows you to group Threads together.  There is a hierarchy
  45  * of ThreadGroups, and only the initial ThreadGroup has no parent.  A Thread
  46  * may access information about its own ThreadGroup, but not its parents or
  47  * others outside the tree.
  48  *
  49  * @author John Keiser
  50  * @author Tom Tromey
  51  * @author Bryce McKinlay
  52  * @author Eric Blake (ebb9@email.byu.edu)
  53  * @see Thread
  54  * @since 1.0
  55  * @status updated to 1.4
  56  */
  57 public class ThreadGroup implements UncaughtExceptionHandler
  58 {
  59   /** The Initial, top-level ThreadGroup. */
  60   static ThreadGroup root = new ThreadGroup();
  61
  62   /**
  63    * This flag is set if an uncaught exception occurs. The runtime should
  64    * check this and exit with an error status if it is set.
  65    */
  66   static boolean had_uncaught_exception;
  67
  68   /** The parent thread group. */
  69   private final ThreadGroup parent;
  70
  71   /** The group name, non-null. */
  72   final String name;
  73
  74   /** The threads in the group. */
  75   private final Vector threads = new Vector();
  76
  77   /** Child thread groups, or null when this group is destroyed. */
  78   private Vector groups = new Vector();
  79
  80   /** If all threads in the group are daemons. */
  81   private boolean daemon_flag = false;
  82
  83   /** The maximum group priority. */
  84   private int maxpri;
  85
  86   /**
  87    * Hidden constructor to build the root node.
  88    */
  89   private ThreadGroup()
  90   {
  91     name = "main";
  92     parent = null;
  93     maxpri = Thread.MAX_PRIORITY;
  94   }
  95
  96   /**
  97    * Create a new ThreadGroup using the given name and the current thread's
  98    * ThreadGroup as a parent. There may be a security check,
  99    * <code>checkAccess</code>.
 100    *
 101    * @param name the name to use for the ThreadGroup
 102    * @throws SecurityException if the current thread cannot create a group
 103    * @see #checkAccess()
 104    */
 105   public ThreadGroup(String name)
 106   {
 107     this(Thread.currentThread().group, name);
 108   }
 109
 110   /**
 111    * Create a new ThreadGroup using the given name and parent group. The new
 112    * group inherits the maximum priority and daemon status of its parent
 113    * group. There may be a security check, <code>checkAccess</code>.
 114    *
 115    * @param name the name to use for the ThreadGroup
 116    * @param parent the ThreadGroup to use as a parent
 117    * @throws NullPointerException if parent is null
 118    * @throws SecurityException if the current thread cannot create a group
 119    * @throws IllegalThreadStateException if the parent is destroyed
 120    * @see #checkAccess()
 121    */
 122   public ThreadGroup(ThreadGroup parent, String name)
 123   {
 124     parent.checkAccess();
 125     this.parent = parent;
 126     this.name = name;
 127     maxpri = parent.maxpri;
 128     daemon_flag = parent.daemon_flag;
 129     synchronized (parent)
 130       {
 131         if (parent.groups == null)
 132           throw new IllegalThreadStateException();
 133         parent.groups.add(this);
 134       }
 135   }
 136
 137   /**
 138    * Get the name of this ThreadGroup.
 139    *
 140    * @return the name of this ThreadGroup
 141    */
 142   public final String getName()
 143   {
 144     return name;
 145   }
 146
 147   /**
 148    * Get the parent of this ThreadGroup. If the parent is not null, there
 149    * may be a security check, <code>checkAccess</code>.
 150    *
 151    * @return the parent of this ThreadGroup
 152    * @throws SecurityException if permission is denied
 153    */
 154   public final ThreadGroup getParent()
 155   {
 156     if (parent != null)
 157       parent.checkAccess();
 158     return parent;
 159   }
 160
 161   /**
 162    * Get the maximum priority of Threads in this ThreadGroup. Threads created
 163    * after this call in this group may not exceed this priority.
 164    *
 165    * @return the maximum priority of Threads in this ThreadGroup
 166    */
 167   public final int getMaxPriority()
 168   {
 169     return maxpri;
 170   }
 171
 172   /**
 173    * Tell whether this ThreadGroup is a daemon group.  A daemon group will
 174    * be automatically destroyed when its last thread is stopped and
 175    * its last thread group is destroyed.
 176    *
 177    * @return whether this ThreadGroup is a daemon group
 178    */
 179   public final boolean isDaemon()
 180   {
 181     return daemon_flag;
 182   }
 183
 184   /**
 185    * Tell whether this ThreadGroup has been destroyed or not.
 186    *
 187    * @return whether this ThreadGroup has been destroyed or not
 188    * @since 1.1
 189    */
 190   public synchronized boolean isDestroyed()
 191   {
 192     return groups == null;
 193   }
 194
 195   /**
 196    * Set whether this ThreadGroup is a daemon group.  A daemon group will be
 197    * destroyed when its last thread is stopped and its last thread group is
 198    * destroyed. There may be a security check, <code>checkAccess</code>.
 199    *
 200    * @param daemon whether this ThreadGroup should be a daemon group
 201    * @throws SecurityException if you cannot modify this ThreadGroup
 202    * @see #checkAccess()
 203    */
 204   public final void setDaemon(boolean daemon)
 205   {
 206     checkAccess();
 207     daemon_flag = daemon;
 208   }
 209
 210   /**
 211    * Set the maximum priority for Threads in this ThreadGroup. setMaxPriority
 212    * can only be used to reduce the current maximum. If maxpri is greater
 213    * than the current Maximum of the parent group, the current value is not
 214    * changed. Otherwise, all groups which belong to this have their priority
 215    * adjusted as well. Calling this does not affect threads already in this
 216    * ThreadGroup. There may be a security check, <code>checkAccess</code>.
 217    *
 218    * @param maxpri the new maximum priority for this ThreadGroup
 219    * @throws SecurityException if you cannot modify this ThreadGroup
 220    * @see #getMaxPriority()
 221    * @see #checkAccess()
 222    */
 223   public final synchronized void setMaxPriority(int maxpri)
 224   {
 225     checkAccess();
 226     if (maxpri < Thread.MIN_PRIORITY || maxpri > Thread.MAX_PRIORITY)
 227       return;
 228     if (parent != null && maxpri > parent.maxpri)
 229       maxpri = parent.maxpri;
 230     this.maxpri = maxpri;
 231     if (groups == null)
 232       return;
 233     int i = groups.size();
 234     while (--i >= 0)
 235       ((ThreadGroup) groups.get(i)).setMaxPriority(maxpri);
 236   }
 237
 238   /**
 239    * Check whether this ThreadGroup is an ancestor of the specified
 240    * ThreadGroup, or if they are the same.
 241    *
 242    * @param group the group to test on
 243    * @return whether this ThreadGroup is a parent of the specified group
 244    */
 245   public final boolean parentOf(ThreadGroup group)
 246   {
 247     while (group != null)
 248       {
 249         if (group == this)
 250           return true;
 251         group = group.parent;
 252       }
 253     return false;
 254   }
 255
 256   /**
 257    * Find out if the current Thread can modify this ThreadGroup. This passes
 258    * the check on to <code>SecurityManager.checkAccess(this)</code>.
 259    *
 260    * @throws SecurityException if the current Thread cannot modify this
 261    *         ThreadGroup
 262    * @see SecurityManager#checkAccess(ThreadGroup)
 263    */
 264   public final void checkAccess()
 265   {
 266     // Bypass System.getSecurityManager, for bootstrap efficiency.
 267     SecurityManager sm = SecurityManager.current;
 268     if (sm != null)
 269       sm.checkAccess(this);
 270   }
 271
 272   /**
 273    * Return an estimate of the total number of active threads in this
 274    * ThreadGroup and all its descendants. This cannot return an exact number,
 275    * since the status of threads may change after they were counted; but it
 276    * should be pretty close. Based on a JDC bug,
 277    * <a href="http://developer.java.sun.com/developer/bugParade/bugs/4089701.html">
 278    * 4089701</a>, we take active to mean isAlive().
 279    *
 280    * @return count of active threads in this ThreadGroup and its descendants
 281    */
 282   public int activeCount()
 283   {
 284     int total = 0;
 285     if (groups == null)
 286       return total;
 287     int i = threads.size();
 288     while (--i >= 0)
 289       if (((Thread) threads.get(i)).isAlive())
 290         total++;
 291     i = groups.size();
 292     while (--i >= 0)
 293       total += ((ThreadGroup) groups.get(i)).activeCount();
 294     return total;
 295   }
 296
 297   /**
 298    * Copy all of the active Threads from this ThreadGroup and its descendants
 299    * into the specified array.  If the array is not big enough to hold all
 300    * the Threads, extra Threads will simply not be copied. There may be a
 301    * security check, <code>checkAccess</code>.
 302    *
 303    * @param array the array to put the threads into
 304    * @return the number of threads put into the array
 305    * @throws SecurityException if permission was denied
 306    * @throws NullPointerException if array is null
 307    * @throws ArrayStoreException if a thread does not fit in the array
 308    * @see #activeCount()
 309    * @see #checkAccess()
 310    * @see #enumerate(Thread[], boolean)
 311    */
 312   public int enumerate(Thread[] array)
 313   {
 314     return enumerate(array, 0, true);
 315   }
 316
 317   /**
 318    * Copy all of the active Threads from this ThreadGroup and, if desired,
 319    * from its descendants, into the specified array. If the array is not big
 320    * enough to hold all the Threads, extra Threads will simply not be copied.
 321    * There may be a security check, <code>checkAccess</code>.
 322    *
 323    * @param array the array to put the threads into
 324    * @param recurse whether to recurse into descendent ThreadGroups
 325    * @return the number of threads put into the array
 326    * @throws SecurityException if permission was denied
 327    * @throws NullPointerException if array is null
 328    * @throws ArrayStoreException if a thread does not fit in the array
 329    * @see #activeCount()
 330    * @see #checkAccess()
 331    */
 332   public int enumerate(Thread[] array, boolean recurse)
 333   {
 334     return enumerate(array, 0, recurse);
 335   }
 336
 337   /**
 338    * Get the number of active groups in this ThreadGroup.  This group itself
 339    * is not included in the count. A sub-group is active if it has not been
 340    * destroyed. This cannot return an exact number, since the status of
 341    * threads may change after they were counted; but it should be pretty close.
 342    *
 343    * @return the number of active groups in this ThreadGroup
 344    */
 345   public int activeGroupCount()
 346   {
 347     if (groups == null)
 348       return 0;
 349     int total = groups.size();
 350     int i = total;
 351     while (--i >= 0)
 352       total += ((ThreadGroup) groups.get(i)).activeGroupCount();
 353     return total;
 354   }
 355
 356   /**
 357    * Copy all active ThreadGroups that are descendants of this ThreadGroup
 358    * into the specified array.  If the array is not large enough to hold all
 359    * active ThreadGroups, extra ThreadGroups simply will not be copied. There
 360    * may be a security check, <code>checkAccess</code>.
 361    *
 362    * @param array the array to put the ThreadGroups into
 363    * @return the number of ThreadGroups copied into the array
 364    * @throws SecurityException if permission was denied
 365    * @throws NullPointerException if array is null
 366    * @throws ArrayStoreException if a group does not fit in the array
 367    * @see #activeCount()
 368    * @see #checkAccess()
 369    * @see #enumerate(ThreadGroup[], boolean)
 370    */
 371   public int enumerate(ThreadGroup[] array)
 372   {
 373     return enumerate(array, 0, true);
 374   }
 375
 376   /**
 377    * Copy all active ThreadGroups that are children of this ThreadGroup into
 378    * the specified array, and if desired, also all descendents.  If the array
 379    * is not large enough to hold all active ThreadGroups, extra ThreadGroups
 380    * simply will not be copied. There may be a security check,
 381    * <code>checkAccess</code>.
 382    *
 383    * @param array the array to put the ThreadGroups into
 384    * @param recurse whether to recurse into descendent ThreadGroups
 385    * @return the number of ThreadGroups copied into the array
 386    * @throws SecurityException if permission was denied
 387    * @throws NullPointerException if array is null
 388    * @throws ArrayStoreException if a group does not fit in the array
 389    * @see #activeCount()
 390    * @see #checkAccess()
 391    */
 392   public int enumerate(ThreadGroup[] array, boolean recurse)
 393   {
 394     return enumerate(array, 0, recurse);
 395   }
 396
 397   /**
 398    * Stop all Threads in this ThreadGroup and its descendants.
 399    *
 400    * <p>This is inherently unsafe, as it can interrupt synchronized blocks and
 401    * leave data in bad states.  Hence, there is a security check:
 402    * <code>checkAccess()</code>, followed by further checks on each thread
 403    * being stopped.
 404    *
 405    * @throws SecurityException if permission is denied
 406    * @see #checkAccess()
 407    * @see Thread#stop(Throwable)
 408    * @deprecated unsafe operation, try not to use
 409    */
 410   public final synchronized void stop()
 411   {
 412     checkAccess();
 413     if (groups == null)
 414       return;
 415     int i = threads.size();
 416     while (--i >= 0)
 417       ((Thread) threads.get(i)).stop();
 418     i = groups.size();
 419     while (--i >= 0)
 420       ((ThreadGroup) groups.get(i)).stop();
 421   }
 422
 423   /**
 424    * Interrupt all Threads in this ThreadGroup and its sub-groups. There may
 425    * be a security check, <code>checkAccess</code>.
 426    *
 427    * @throws SecurityException if permission is denied
 428    * @see #checkAccess()
 429    * @see Thread#interrupt()
 430    * @since 1.2
 431    */
 432   public final synchronized void interrupt()
 433   {
 434     checkAccess();
 435     if (groups == null)
 436       return;
 437     int i = threads.size();
 438     while (--i >= 0)
 439       ((Thread) threads.get(i)).interrupt();
 440     i = groups.size();
 441     while (--i >= 0)
 442       ((ThreadGroup) groups.get(i)).interrupt();
 443   }
 444
 445   /**
 446    * Suspend all Threads in this ThreadGroup and its descendants.
 447    *
 448    * <p>This is inherently unsafe, as suspended threads still hold locks,
 449    * which can lead to deadlock.  Hence, there is a security check:
 450    * <code>checkAccess()</code>, followed by further checks on each thread
 451    * being suspended.
 452    *
 453    * @throws SecurityException if permission is denied
 454    * @see #checkAccess()
 455    * @see Thread#suspend()
 456    * @deprecated unsafe operation, try not to use
 457    */
 458   public final synchronized void suspend()
 459   {
 460     checkAccess();
 461     if (groups == null)
 462       return;
 463     int i = threads.size();
 464     while (--i >= 0)
 465       ((Thread) threads.get(i)).suspend();
 466     i = groups.size();
 467     while (--i >= 0)
 468       ((ThreadGroup) groups.get(i)).suspend();
 469   }
 470
 471   /**
 472    * Resume all suspended Threads in this ThreadGroup and its descendants.
 473    * To mirror suspend(), there is a security check:
 474    * <code>checkAccess()</code>, followed by further checks on each thread
 475    * being resumed.
 476    *
 477    * @throws SecurityException if permission is denied
 478    * @see #checkAccess()
 479    * @see Thread#suspend()
 480    * @deprecated pointless, since suspend is deprecated
 481    */
 482   public final synchronized void resume()
 483   {
 484     checkAccess();
 485     if (groups == null)
 486       return;
 487     int i = threads.size();
 488     while (--i >= 0)
 489       ((Thread) threads.get(i)).resume();
 490     i = groups.size();
 491     while (--i >= 0)
 492       ((ThreadGroup) groups.get(i)).resume();
 493   }
 494
 495   /**
 496    * Destroy this ThreadGroup.  The group must be empty, meaning that all
 497    * threads and sub-groups have completed execution. Daemon groups are
 498    * destroyed automatically. There may be a security check,
 499    * <code>checkAccess</code>.
 500    *
 501    * @throws IllegalThreadStateException if the ThreadGroup is not empty, or
 502    *         was previously destroyed
 503    * @throws SecurityException if permission is denied
 504    * @see #checkAccess()
 505    */
 506   public final synchronized void destroy()
 507   {
 508     checkAccess();
 509     if (! threads.isEmpty() || groups == null)
 510       throw new IllegalThreadStateException();
 511     int i = groups.size();
 512     while (--i >= 0)
 513       ((ThreadGroup) groups.get(i)).destroy();
 514     groups = null;
 515     if (parent != null)
 516       parent.removeGroup(this);
 517   }
 518
 519   /**
 520    * Print out information about this ThreadGroup to System.out. This is
 521    * meant for debugging purposes. <b>WARNING:</b> This method is not secure,
 522    * and can print the name of threads to standard out even when you cannot
 523    * otherwise get at such threads.
 524    */
 525   public void list()
 526   {
 527     list("");
 528   }
 529
 530   /**
 531    * When a Thread in this ThreadGroup does not catch an exception, the
 532    * virtual machine calls this method. The default implementation simply
 533    * passes the call to the parent; then in top ThreadGroup, it will
 534    * ignore ThreadDeath and print the stack trace of any other throwable.
 535    * Override this method if you want to handle the exception in a different
 536    * manner.
 537    *
 538    * @param thread the thread that exited
 539    * @param t the uncaught throwable
 540    * @throws NullPointerException if t is null
 541    * @see ThreadDeath
 542    * @see System#err
 543    * @see Throwable#printStackTrace()
 544    */
 545   public void uncaughtException(Thread thread, Throwable t)
 546   {
 547     if (parent != null)
 548       parent.uncaughtException(thread, t);
 549     else if (Thread.getDefaultUncaughtExceptionHandler() != null)
 550       Thread.getDefaultUncaughtExceptionHandler().uncaughtException(thread, t);
 551     else if (! (t instanceof ThreadDeath))
 552       {
 553         if (t == null)
 554           throw new NullPointerException();
 555         had_uncaught_exception = true;
 556         try
 557           {
 558             if (thread != null)
 559               System.err.print("Exception in thread \"" + thread.name + "\" ");
 560             t.printStackTrace(System.err);
 561           }
 562         catch (Throwable x)
 563           {
 564             // This means that something is badly screwed up with the runtime,
 565             // or perhaps someone overloaded the Throwable.printStackTrace to
 566             // die. In any case, try to deal with it gracefully.
 567             try
 568               {
 569                 System.err.println(t);
 570                 System.err.println("*** Got " + x
 571                                    + " while trying to print stack trace.");
 572               }
 573             catch (Throwable x2)
 574               {
 575                 // Here, someone may have overloaded t.toString() or
 576                 // x.toString() to die. Give up all hope; we can't even chain
 577                 // the exception, because the chain would likewise die.
 578                 System.err.println("*** Catastrophic failure while handling "
 579                                    + "uncaught exception.");
 580                 throw new InternalError();
 581               }
 582           }
 583       }
 584   }
 585
 586   /**
 587    * Originally intended to tell the VM whether it may suspend Threads in
 588    * low memory situations, this method was never implemented by Sun, and
 589    * is hence a no-op.
 590    *
 591    * @param allow whether to allow low-memory thread suspension; ignored
 592    * @return false
 593    * @since 1.1
 594    * @deprecated pointless, since suspend is deprecated
 595    */
 596   public boolean allowThreadSuspension(boolean allow)
 597   {
 598     return false;
 599   }
 600
 601   /**
 602    * Return a human-readable String representing this ThreadGroup. The format
 603    * of the string is:<br>
 604    * <code>getClass().getName() + "[name=" + getName() + ",maxpri="
 605    * + getMaxPriority() + ']'</code>.
 606    *
 607    * @return a human-readable String representing this ThreadGroup
 608    */
 609   public String toString()
 610   {
 611     return getClass().getName() + "[name=" + name + ",maxpri=" + maxpri + ']';
 612   }
 613
 614   /**
 615    * Implements enumerate.
 616    *
 617    * @param list the array to put the threads into
 618    * @param next the next open slot in the array
 619    * @param recurse whether to recurse into descendent ThreadGroups
 620    * @return the number of threads put into the array
 621    * @throws SecurityException if permission was denied
 622    * @throws NullPointerException if list is null
 623    * @throws ArrayStoreException if a thread does not fit in the array
 624    * @see #enumerate(Thread[])
 625    * @see #enumerate(Thread[], boolean)
 626    */
 627   private int enumerate(Thread[] list, int next, boolean recurse)
 628   {
 629     checkAccess();
 630     if (groups == null)
 631       return next;
 632     int i = threads.size();
 633     while (--i >= 0 && next < list.length)
 634       {
 635         Thread t = (Thread) threads.get(i);
 636         if (t.isAlive())
 637           list[next++] = t;
 638       }
 639     if (recurse)
 640       {
 641         i = groups.size();
 642         while (--i >= 0 && next < list.length)
 643           {
 644             ThreadGroup g = (ThreadGroup) groups.get(i);
 645             next = g.enumerate(list, next, true);
 646           }
 647       }
 648     return next;
 649   }
 650
 651   /**
 652    * Implements enumerate.
 653    *
 654    * @param list the array to put the groups into
 655    * @param next the next open slot in the array
 656    * @param recurse whether to recurse into descendent ThreadGroups
 657    * @return the number of groups put into the array
 658    * @throws SecurityException if permission was denied
 659    * @throws NullPointerException if list is null
 660    * @throws ArrayStoreException if a group does not fit in the array
 661    * @see #enumerate(ThreadGroup[])
 662    * @see #enumerate(ThreadGroup[], boolean)
 663    */
 664   private int enumerate(ThreadGroup[] list, int next, boolean recurse)
 665   {
 666     checkAccess();
 667     if (groups == null)
 668       return next;
 669     int i = groups.size();
 670     while (--i >= 0 && next < list.length)
 671       {
 672         ThreadGroup g = (ThreadGroup) groups.get(i);
 673         list[next++] = g;
 674         if (recurse && next != list.length)
 675           next = g.enumerate(list, next, true);
 676       }
 677     return next;
 678   }
 679
 680   /**
 681    * Implements list.
 682    *
 683    * @param indentation the current level of indentation
 684    * @see #list()
 685    */
 686   private void list(String indentation)
 687   {
 688     if (groups == null)
 689       return;
 690     System.out.println(indentation + this);
 691     indentation += "    ";
 692     int i = threads.size();
 693     while (--i >= 0)
 694       System.out.println(indentation + threads.get(i));
 695     i = groups.size();
 696     while (--i >= 0)
 697       ((ThreadGroup) groups.get(i)).list(indentation);
 698   }
 699
 700   /**
 701    * Add a thread to the group. Called by Thread constructors.
 702    *
 703    * @param t the thread to add, non-null
 704    * @throws IllegalThreadStateException if the group is destroyed
 705    */
 706   final synchronized void addThread(Thread t)
 707   {
 708     if (groups == null)
 709       throw new IllegalThreadStateException("ThreadGroup is destroyed");
 710     threads.add(t);
 711   }
 712
 713   /**
 714    * Called by the VM to remove a thread that has died.
 715    *
 716    * @param t the thread to remove, non-null
 717    * @XXX A ThreadListener to call this might be nice.
 718    */
 719   final synchronized void removeThread(Thread t)
 720   {
 721     if (groups == null)
 722       return;
 723     threads.remove(t);
 724     t.group = null;
 725     // Daemon groups are automatically destroyed when all their threads die.
 726     if (daemon_flag && groups.size() == 0 && threads.size() == 0)
 727       {
 728         // We inline destroy to avoid the access check.
 729         groups = null;
 730         if (parent != null)
 731           parent.removeGroup(this);
 732       }
 733   }
 734
 735   /**
 736    * Called when a group is destroyed, to remove it from its parent.
 737    *
 738    * @param g the destroyed group, non-null
 739    */
 740   final synchronized void removeGroup(ThreadGroup g)
 741   {
 742     groups.remove(g);
 743     // Daemon groups are automatically destroyed when all their threads die.
 744     if (daemon_flag && groups.size() == 0 && threads.size() == 0)
 745       {
 746         // We inline destroy to avoid the access check.
 747         groups = null;
 748         if (parent != null)
 749           parent.removeGroup(this);
 750       }
 751   }
 752 } // class ThreadGroup