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 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 */ ThreadGroup()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 */ ThreadGroup(String name)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 */ ThreadGroup(ThreadGroup parent, String name)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 */ getName()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 */ getParent()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 */ getMaxPriority()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 */ isDaemon()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 */ isDestroyed()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 */ setDaemon(boolean daemon)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 */ setMaxPriority(int maxpri)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 */ parentOf(ThreadGroup group)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 */ checkAccess()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 */ activeCount()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 */ enumerate(Thread[] array)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 */ enumerate(Thread[] array, boolean recurse)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 */ activeGroupCount()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 */ enumerate(ThreadGroup[] array)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 */ enumerate(ThreadGroup[] array, boolean recurse)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 */ stop()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 */ interrupt()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 */ suspend()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 */ resume()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 */ destroy()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 */ list()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 */ uncaughtException(Thread thread, Throwable t)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 */ allowThreadSuspension(boolean allow)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 */ toString()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 */ enumerate(Thread[] list, int next, boolean recurse)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 */ enumerate(ThreadGroup[] list, int next, boolean recurse)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 */ list(String indentation)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 */ addThread(Thread t)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 */ removeThread(Thread t)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 */ removeGroup(ThreadGroup g)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 */ getThreadFromId(long id)759 static Thread getThreadFromId(long id) 760 { 761 return root.getThreadFromIdImpl(id); 762 } 763 getThreadFromIdImpl(long id)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 792