001/* ThreadGroup -- a group of Threads
002   Copyright (C) 1998, 2000, 2001, 2002, 2005  Free Software Foundation, Inc.
003
004This file is part of GNU Classpath.
005
006GNU Classpath is free software; you can redistribute it and/or modify
007it under the terms of the GNU General Public License as published by
008the Free Software Foundation; either version 2, or (at your option)
009any later version.
010
011GNU Classpath is distributed in the hope that it will be useful, but
012WITHOUT ANY WARRANTY; without even the implied warranty of
013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014General Public License for more details.
015
016You should have received a copy of the GNU General Public License
017along with GNU Classpath; see the file COPYING.  If not, write to the
018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
01902110-1301 USA.
020
021Linking this library statically or dynamically with other modules is
022making a combined work based on this library.  Thus, the terms and
023conditions of the GNU General Public License cover the whole
024combination.
025
026As a special exception, the copyright holders of this library give you
027permission to link this library with independent modules to produce an
028executable, regardless of the license terms of these independent
029modules, and to copy and distribute the resulting executable under
030terms of your choice, provided that you also meet, for each linked
031independent module, the terms and conditions of the license of that
032module.  An independent module is a module which is not derived from
033or based on this library.  If you modify this library, you may extend
034this exception to your version of the library, but you are not
035obligated to do so.  If you do not wish to do so, delete this
036exception statement from your version. */
037
038package java.lang;
039
040import java.lang.Thread.UncaughtExceptionHandler;
041import java.util.Vector;
042
043/**
044 * ThreadGroup allows you to group Threads together.  There is a hierarchy
045 * of ThreadGroups, and only the initial ThreadGroup has no parent.  A Thread
046 * may access information about its own ThreadGroup, but not its parents or
047 * others outside the tree.
048 *
049 * @author John Keiser
050 * @author Tom Tromey
051 * @author Bryce McKinlay
052 * @author Eric Blake (ebb9@email.byu.edu)
053 * @see Thread
054 * @since 1.0
055 * @status updated to 1.4
056 */
057public class ThreadGroup implements UncaughtExceptionHandler
058{
059  /** The Initial, top-level ThreadGroup. */
060  static ThreadGroup root = new ThreadGroup();
061
062  /**
063   * This flag is set if an uncaught exception occurs. The runtime should
064   * check this and exit with an error status if it is set.
065   */
066  static boolean had_uncaught_exception;
067
068  /** The parent thread group. */
069  final ThreadGroup parent;
070
071  /** The group name, non-null. */
072  final String name;
073
074  /** The threads in the group. */
075  private final Vector threads = new Vector();
076
077  /** Child thread groups, or null when this group is destroyed. */
078  private Vector groups = new Vector();
079
080  /** If all threads in the group are daemons. */
081  private boolean daemon_flag = false;
082
083  /** The maximum group priority. */
084  private int maxpri;
085
086  /**
087   * Hidden constructor to build the root node.
088   */
089  private ThreadGroup()
090  {
091    name = "main";
092    parent = null;
093    maxpri = Thread.MAX_PRIORITY;
094  }
095
096  /**
097   * Create a new ThreadGroup using the given name and the current thread's
098   * ThreadGroup as a parent. There may be a security check,
099   * <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
753  /*
754   * Helper method for the VM. Find a Thread by its Id.
755   *
756   * @param id The Thread Id.
757   * @return Thread object or null if thread doesn't exist.
758   */
759  static Thread getThreadFromId(long id)
760  {
761    return root.getThreadFromIdImpl(id);
762  }
763
764  private Thread getThreadFromIdImpl(long id)
765  {
766    synchronized (threads)
767      {
768        for (int i = 0; i < threads.size(); i++)
769          {
770            Thread t = (Thread) threads.get(i);
771            if (t.getId() == id)
772              return t;
773          }
774      }
775    Vector groups = this.groups;
776    if (groups != null)
777      {
778        synchronized (groups)
779          {
780            for (int i = 0; i < groups.size(); i++)
781              {
782                ThreadGroup g = (ThreadGroup) groups.get(i);
783                Thread t = g.getThreadFromIdImpl(id);
784                if (t != null)
785                  return t;
786              }
787          }
788      }
789    return null;
790  }
791} // class ThreadGroup