001 /* ThreadGroup -- a group of Threads
002 Copyright (C) 1998, 2000, 2001, 2002, 2005 Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038 package java.lang;
039
040 import java.lang.Thread.UncaughtExceptionHandler;
041 import 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 */
057 public 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