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