/*
* Copyright (c) 1995, 2012, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package java.lang;
import java.io.
PrintStream;
import java.util.
Arrays;
import sun.misc.
VM;
/**
* A thread group represents a set of threads. In addition, a thread
* group can also include other thread groups. The thread groups form
* a tree in which every thread group except the initial thread group
* has a parent.
* <p>
* A thread is allowed to access information about its own thread
* group, but not to access information about its thread group's
* parent thread group or any other thread groups.
*
* @author unascribed
* @since JDK1.0
*/
/* The locking strategy for this code is to try to lock only one level of the
* tree wherever possible, but otherwise to lock from the bottom up.
* That is, from child thread groups to parents.
* This has the advantage of limiting the number of locks that need to be held
* and in particular avoids having to grab the lock for the root thread group,
* (or a global lock) which would be a source of contention on a
* multi-processor system with many thread groups.
* This policy often leads to taking a snapshot of the state of a thread group
* and working off of that snapshot, rather than holding the thread group locked
* while we work on the children.
*/
public
class
ThreadGroup implements
Thread.
UncaughtExceptionHandler {
private final
ThreadGroup parent;
String name;
int
maxPriority;
boolean
destroyed;
boolean
daemon;
boolean
vmAllowSuspension;
int
nUnstartedThreads = 0;
int
nthreads;
Thread threads[];
int
ngroups;
ThreadGroup groups[];
/**
* Creates an empty Thread group that is not in any Thread group.
* This method is used to create the system Thread group.
*/
private
ThreadGroup() { // called from C code
this.
name = "system";
this.
maxPriority =
Thread.
MAX_PRIORITY;
this.
parent = null;
}
/**
* Constructs a new thread group. The parent of this new group is
* the thread group of the currently running thread.
* <p>
* The <code>checkAccess</code> method of the parent thread group is
* called with no arguments; this may result in a security exception.
*
* @param name the name of the new thread group.
* @exception SecurityException if the current thread cannot create a
* thread in the specified thread group.
* @see java.lang.ThreadGroup#checkAccess()
* @since JDK1.0
*/
public
ThreadGroup(
String name) {
this(
Thread.
currentThread().
getThreadGroup(),
name);
}
/**
* Creates a new thread group. The parent of this new group is the
* specified thread group.
* <p>
* The <code>checkAccess</code> method of the parent thread group is
* called with no arguments; this may result in a security exception.
*
* @param parent the parent thread group.
* @param name the name of the new thread group.
* @exception NullPointerException if the thread group argument is
* <code>null</code>.
* @exception SecurityException if the current thread cannot create a
* thread in the specified thread group.
* @see java.lang.SecurityException
* @see java.lang.ThreadGroup#checkAccess()
* @since JDK1.0
*/
public
ThreadGroup(
ThreadGroup parent,
String name) {
this(
checkParentAccess(
parent),
parent,
name);
}
private
ThreadGroup(
Void unused,
ThreadGroup parent,
String name) {
this.
name =
name;
this.
maxPriority =
parent.
maxPriority;
this.
daemon =
parent.
daemon;
this.
vmAllowSuspension =
parent.
vmAllowSuspension;
this.
parent =
parent;
parent.
add(this);
}
/*
* @throws NullPointerException if the parent argument is {@code null}
* @throws SecurityException if the current thread cannot create a
* thread in the specified thread group.
*/
private static
Void checkParentAccess(
ThreadGroup parent) {
parent.
checkAccess();
return null;
}
/**
* Returns the name of this thread group.
*
* @return the name of this thread group.
* @since JDK1.0
*/
public final
String getName() {
return
name;
}
/**
* Returns the parent of this thread group.
* <p>
* First, if the parent is not <code>null</code>, the
* <code>checkAccess</code> method of the parent thread group is
* called with no arguments; this may result in a security exception.
*
* @return the parent of this thread group. The top-level thread group
* is the only thread group whose parent is <code>null</code>.
* @exception SecurityException if the current thread cannot modify
* this thread group.
* @see java.lang.ThreadGroup#checkAccess()
* @see java.lang.SecurityException
* @see java.lang.RuntimePermission
* @since JDK1.0
*/
public final
ThreadGroup getParent() {
if (
parent != null)
parent.
checkAccess();
return
parent;
}
/**
* Returns the maximum priority of this thread group. Threads that are
* part of this group cannot have a higher priority than the maximum
* priority.
*
* @return the maximum priority that a thread in this thread group
* can have.
* @see #setMaxPriority
* @since JDK1.0
*/
public final int
getMaxPriority() {
return
maxPriority;
}
/**
* Tests if this thread group is a daemon thread group. A
* daemon thread group is automatically destroyed when its last
* thread is stopped or its last thread group is destroyed.
*
* @return <code>true</code> if this thread group is a daemon thread group;
* <code>false</code> otherwise.
* @since JDK1.0
*/
public final boolean
isDaemon() {
return
daemon;
}
/**
* Tests if this thread group has been destroyed.
*
* @return true if this object is destroyed
* @since JDK1.1
*/
public synchronized boolean
isDestroyed() {
return
destroyed;
}
/**
* Changes the daemon status of this thread group.
* <p>
* First, the <code>checkAccess</code> method of this thread group is
* called with no arguments; this may result in a security exception.
* <p>
* A daemon thread group is automatically destroyed when its last
* thread is stopped or its last thread group is destroyed.
*
* @param daemon if <code>true</code>, marks this thread group as
* a daemon thread group; otherwise, marks this
* thread group as normal.
* @exception SecurityException if the current thread cannot modify
* this thread group.
* @see java.lang.SecurityException
* @see java.lang.ThreadGroup#checkAccess()
* @since JDK1.0
*/
public final void
setDaemon(boolean
daemon) {
checkAccess();
this.
daemon =
daemon;
}
/**
* Sets the maximum priority of the group. Threads in the thread
* group that already have a higher priority are not affected.
* <p>
* First, the <code>checkAccess</code> method of this thread group is
* called with no arguments; this may result in a security exception.
* <p>
* If the <code>pri</code> argument is less than
* {@link Thread#MIN_PRIORITY} or greater than
* {@link Thread#MAX_PRIORITY}, the maximum priority of the group
* remains unchanged.
* <p>
* Otherwise, the priority of this ThreadGroup object is set to the
* smaller of the specified <code>pri</code> and the maximum permitted
* priority of the parent of this thread group. (If this thread group
* is the system thread group, which has no parent, then its maximum
* priority is simply set to <code>pri</code>.) Then this method is
* called recursively, with <code>pri</code> as its argument, for
* every thread group that belongs to this thread group.
*
* @param pri the new priority of the thread group.
* @exception SecurityException if the current thread cannot modify
* this thread group.
* @see #getMaxPriority
* @see java.lang.SecurityException
* @see java.lang.ThreadGroup#checkAccess()
* @since JDK1.0
*/
public final void
setMaxPriority(int
pri) {
int
ngroupsSnapshot;
ThreadGroup[]
groupsSnapshot;
synchronized (this) {
checkAccess();
if (
pri <
Thread.
MIN_PRIORITY ||
pri >
Thread.
MAX_PRIORITY) {
return;
}
maxPriority = (
parent != null) ?
Math.
min(
pri,
parent.
maxPriority) :
pri;
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i++) {
groupsSnapshot[
i].
setMaxPriority(
pri);
}
}
/**
* Tests if this thread group is either the thread group
* argument or one of its ancestor thread groups.
*
* @param g a thread group.
* @return <code>true</code> if this thread group is the thread group
* argument or one of its ancestor thread groups;
* <code>false</code> otherwise.
* @since JDK1.0
*/
public final boolean
parentOf(
ThreadGroup g) {
for (;
g != null ;
g =
g.
parent) {
if (
g == this) {
return true;
}
}
return false;
}
/**
* Determines if the currently running thread has permission to
* modify this thread group.
* <p>
* If there is a security manager, its <code>checkAccess</code> method
* is called with this thread group as its argument. This may result
* in throwing a <code>SecurityException</code>.
*
* @exception SecurityException if the current thread is not allowed to
* access this thread group.
* @see java.lang.SecurityManager#checkAccess(java.lang.ThreadGroup)
* @since JDK1.0
*/
public final void
checkAccess() {
SecurityManager security =
System.
getSecurityManager();
if (
security != null) {
security.
checkAccess(this);
}
}
/**
* Returns an estimate of the number of active threads in this thread
* group and its subgroups. Recursively iterates over all subgroups in
* this thread group.
*
* <p> The value returned is only an estimate because the number of
* threads may change dynamically while this method traverses internal
* data structures, and might be affected by the presence of certain
* system threads. This method is intended primarily for debugging
* and monitoring purposes.
*
* @return an estimate of the number of active threads in this thread
* group and in any other thread group that has this thread
* group as an ancestor
*
* @since JDK1.0
*/
public int
activeCount() {
int
result;
// Snapshot sub-group data so we don't hold this lock
// while our children are computing.
int
ngroupsSnapshot;
ThreadGroup[]
groupsSnapshot;
synchronized (this) {
if (
destroyed) {
return 0;
}
result =
nthreads;
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i++) {
result +=
groupsSnapshot[
i].
activeCount();
}
return
result;
}
/**
* Copies into the specified array every active thread in this
* thread group and its subgroups.
*
* <p> An invocation of this method behaves in exactly the same
* way as the invocation
*
* <blockquote>
* {@linkplain #enumerate(Thread[], boolean) enumerate}{@code (list, true)}
* </blockquote>
*
* @param list
* an array into which to put the list of threads
*
* @return the number of threads put into the array
*
* @throws SecurityException
* if {@linkplain #checkAccess checkAccess} determines that
* the current thread cannot access this thread group
*
* @since JDK1.0
*/
public int
enumerate(
Thread list[]) {
checkAccess();
return
enumerate(
list, 0, true);
}
/**
* Copies into the specified array every active thread in this
* thread group. If {@code recurse} is {@code true},
* this method recursively enumerates all subgroups of this
* thread group and references to every active thread in these
* subgroups are also included. If the array is too short to
* hold all the threads, the extra threads are silently ignored.
*
* <p> An application might use the {@linkplain #activeCount activeCount}
* method to get an estimate of how big the array should be, however
* <i>if the array is too short to hold all the threads, the extra threads
* are silently ignored.</i> If it is critical to obtain every active
* thread in this thread group, the caller should verify that the returned
* int value is strictly less than the length of {@code list}.
*
* <p> Due to the inherent race condition in this method, it is recommended
* that the method only be used for debugging and monitoring purposes.
*
* @param list
* an array into which to put the list of threads
*
* @param recurse
* if {@code true}, recursively enumerate all subgroups of this
* thread group
*
* @return the number of threads put into the array
*
* @throws SecurityException
* if {@linkplain #checkAccess checkAccess} determines that
* the current thread cannot access this thread group
*
* @since JDK1.0
*/
public int
enumerate(
Thread list[], boolean
recurse) {
checkAccess();
return
enumerate(
list, 0,
recurse);
}
private int
enumerate(
Thread list[], int
n, boolean
recurse) {
int
ngroupsSnapshot = 0;
ThreadGroup[]
groupsSnapshot = null;
synchronized (this) {
if (
destroyed) {
return 0;
}
int
nt =
nthreads;
if (
nt >
list.length -
n) {
nt =
list.length -
n;
}
for (int
i = 0;
i <
nt;
i++) {
if (
threads[
i].
isAlive()) {
list[
n++] =
threads[
i];
}
}
if (
recurse) {
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
}
if (
recurse) {
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i++) {
n =
groupsSnapshot[
i].
enumerate(
list,
n, true);
}
}
return
n;
}
/**
* Returns an estimate of the number of active groups in this
* thread group and its subgroups. Recursively iterates over
* all subgroups in this thread group.
*
* <p> The value returned is only an estimate because the number of
* thread groups may change dynamically while this method traverses
* internal data structures. This method is intended primarily for
* debugging and monitoring purposes.
*
* @return the number of active thread groups with this thread group as
* an ancestor
*
* @since JDK1.0
*/
public int
activeGroupCount() {
int
ngroupsSnapshot;
ThreadGroup[]
groupsSnapshot;
synchronized (this) {
if (
destroyed) {
return 0;
}
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
int
n =
ngroupsSnapshot;
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i++) {
n +=
groupsSnapshot[
i].
activeGroupCount();
}
return
n;
}
/**
* Copies into the specified array references to every active
* subgroup in this thread group and its subgroups.
*
* <p> An invocation of this method behaves in exactly the same
* way as the invocation
*
* <blockquote>
* {@linkplain #enumerate(ThreadGroup[], boolean) enumerate}{@code (list, true)}
* </blockquote>
*
* @param list
* an array into which to put the list of thread groups
*
* @return the number of thread groups put into the array
*
* @throws SecurityException
* if {@linkplain #checkAccess checkAccess} determines that
* the current thread cannot access this thread group
*
* @since JDK1.0
*/
public int
enumerate(
ThreadGroup list[]) {
checkAccess();
return
enumerate(
list, 0, true);
}
/**
* Copies into the specified array references to every active
* subgroup in this thread group. If {@code recurse} is
* {@code true}, this method recursively enumerates all subgroups of this
* thread group and references to every active thread group in these
* subgroups are also included.
*
* <p> An application might use the
* {@linkplain #activeGroupCount activeGroupCount} method to
* get an estimate of how big the array should be, however <i>if the
* array is too short to hold all the thread groups, the extra thread
* groups are silently ignored.</i> If it is critical to obtain every
* active subgroup in this thread group, the caller should verify that
* the returned int value is strictly less than the length of
* {@code list}.
*
* <p> Due to the inherent race condition in this method, it is recommended
* that the method only be used for debugging and monitoring purposes.
*
* @param list
* an array into which to put the list of thread groups
*
* @param recurse
* if {@code true}, recursively enumerate all subgroups
*
* @return the number of thread groups put into the array
*
* @throws SecurityException
* if {@linkplain #checkAccess checkAccess} determines that
* the current thread cannot access this thread group
*
* @since JDK1.0
*/
public int
enumerate(
ThreadGroup list[], boolean
recurse) {
checkAccess();
return
enumerate(
list, 0,
recurse);
}
private int
enumerate(
ThreadGroup list[], int
n, boolean
recurse) {
int
ngroupsSnapshot = 0;
ThreadGroup[]
groupsSnapshot = null;
synchronized (this) {
if (
destroyed) {
return 0;
}
int
ng =
ngroups;
if (
ng >
list.length -
n) {
ng =
list.length -
n;
}
if (
ng > 0) {
System.
arraycopy(
groups, 0,
list,
n,
ng);
n +=
ng;
}
if (
recurse) {
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
}
if (
recurse) {
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i++) {
n =
groupsSnapshot[
i].
enumerate(
list,
n, true);
}
}
return
n;
}
/**
* Stops all threads in this thread group.
* <p>
* First, the <code>checkAccess</code> method of this thread group is
* called with no arguments; this may result in a security exception.
* <p>
* This method then calls the <code>stop</code> method on all the
* threads in this thread group and in all of its subgroups.
*
* @exception SecurityException if the current thread is not allowed
* to access this thread group or any of the threads in
* the thread group.
* @see java.lang.SecurityException
* @see java.lang.Thread#stop()
* @see java.lang.ThreadGroup#checkAccess()
* @since JDK1.0
* @deprecated This method is inherently unsafe. See
* {@link Thread#stop} for details.
*/
@
Deprecated
public final void
stop() {
if (
stopOrSuspend(false))
Thread.
currentThread().
stop();
}
/**
* Interrupts all threads in this thread group.
* <p>
* First, the <code>checkAccess</code> method of this thread group is
* called with no arguments; this may result in a security exception.
* <p>
* This method then calls the <code>interrupt</code> method on all the
* threads in this thread group and in all of its subgroups.
*
* @exception SecurityException if the current thread is not allowed
* to access this thread group or any of the threads in
* the thread group.
* @see java.lang.Thread#interrupt()
* @see java.lang.SecurityException
* @see java.lang.ThreadGroup#checkAccess()
* @since 1.2
*/
public final void
interrupt() {
int
ngroupsSnapshot;
ThreadGroup[]
groupsSnapshot;
synchronized (this) {
checkAccess();
for (int
i = 0 ;
i <
nthreads ;
i++) {
threads[
i].
interrupt();
}
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i++) {
groupsSnapshot[
i].
interrupt();
}
}
/**
* Suspends all threads in this thread group.
* <p>
* First, the <code>checkAccess</code> method of this thread group is
* called with no arguments; this may result in a security exception.
* <p>
* This method then calls the <code>suspend</code> method on all the
* threads in this thread group and in all of its subgroups.
*
* @exception SecurityException if the current thread is not allowed
* to access this thread group or any of the threads in
* the thread group.
* @see java.lang.Thread#suspend()
* @see java.lang.SecurityException
* @see java.lang.ThreadGroup#checkAccess()
* @since JDK1.0
* @deprecated This method is inherently deadlock-prone. See
* {@link Thread#suspend} for details.
*/
@
Deprecated
@
SuppressWarnings("deprecation")
public final void
suspend() {
if (
stopOrSuspend(true))
Thread.
currentThread().
suspend();
}
/**
* Helper method: recursively stops or suspends (as directed by the
* boolean argument) all of the threads in this thread group and its
* subgroups, except the current thread. This method returns true
* if (and only if) the current thread is found to be in this thread
* group or one of its subgroups.
*/
@
SuppressWarnings("deprecation")
private boolean
stopOrSuspend(boolean
suspend) {
boolean
suicide = false;
Thread us =
Thread.
currentThread();
int
ngroupsSnapshot;
ThreadGroup[]
groupsSnapshot = null;
synchronized (this) {
checkAccess();
for (int
i = 0 ;
i <
nthreads ;
i++) {
if (
threads[
i]==
us)
suicide = true;
else if (
suspend)
threads[
i].
suspend();
else
threads[
i].
stop();
}
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
}
}
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i++)
suicide =
groupsSnapshot[
i].
stopOrSuspend(
suspend) ||
suicide;
return
suicide;
}
/**
* Resumes all threads in this thread group.
* <p>
* First, the <code>checkAccess</code> method of this thread group is
* called with no arguments; this may result in a security exception.
* <p>
* This method then calls the <code>resume</code> method on all the
* threads in this thread group and in all of its sub groups.
*
* @exception SecurityException if the current thread is not allowed to
* access this thread group or any of the threads in the
* thread group.
* @see java.lang.SecurityException
* @see java.lang.Thread#resume()
* @see java.lang.ThreadGroup#checkAccess()
* @since JDK1.0
* @deprecated This method is used solely in conjunction with
* <tt>Thread.suspend</tt> and <tt>ThreadGroup.suspend</tt>,
* both of which have been deprecated, as they are inherently
* deadlock-prone. See {@link Thread#suspend} for details.
*/
@
Deprecated
@
SuppressWarnings("deprecation")
public final void
resume() {
int
ngroupsSnapshot;
ThreadGroup[]
groupsSnapshot;
synchronized (this) {
checkAccess();
for (int
i = 0 ;
i <
nthreads ;
i++) {
threads[
i].
resume();
}
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i++) {
groupsSnapshot[
i].
resume();
}
}
/**
* Destroys this thread group and all of its subgroups. This thread
* group must be empty, indicating that all threads that had been in
* this thread group have since stopped.
* <p>
* First, the <code>checkAccess</code> method of this thread group is
* called with no arguments; this may result in a security exception.
*
* @exception IllegalThreadStateException if the thread group is not
* empty or if the thread group has already been destroyed.
* @exception SecurityException if the current thread cannot modify this
* thread group.
* @see java.lang.ThreadGroup#checkAccess()
* @since JDK1.0
*/
public final void
destroy() {
int
ngroupsSnapshot;
ThreadGroup[]
groupsSnapshot;
synchronized (this) {
checkAccess();
if (
destroyed || (
nthreads > 0)) {
throw new
IllegalThreadStateException();
}
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
if (
parent != null) {
destroyed = true;
ngroups = 0;
groups = null;
nthreads = 0;
threads = null;
}
}
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i += 1) {
groupsSnapshot[
i].
destroy();
}
if (
parent != null) {
parent.
remove(this);
}
}
/**
* Adds the specified Thread group to this group.
* @param g the specified Thread group to be added
* @exception IllegalThreadStateException If the Thread group has been destroyed.
*/
private final void
add(
ThreadGroup g){
synchronized (this) {
if (
destroyed) {
throw new
IllegalThreadStateException();
}
if (
groups == null) {
groups = new
ThreadGroup[4];
} else if (
ngroups ==
groups.length) {
groups =
Arrays.
copyOf(
groups,
ngroups * 2);
}
groups[
ngroups] =
g;
// This is done last so it doesn't matter in case the
// thread is killed
ngroups++;
}
}
/**
* Removes the specified Thread group from this group.
* @param g the Thread group to be removed
* @return if this Thread has already been destroyed.
*/
private void
remove(
ThreadGroup g) {
synchronized (this) {
if (
destroyed) {
return;
}
for (int
i = 0 ;
i <
ngroups ;
i++) {
if (
groups[
i] ==
g) {
ngroups -= 1;
System.
arraycopy(
groups,
i + 1,
groups,
i,
ngroups -
i);
// Zap dangling reference to the dead group so that
// the garbage collector will collect it.
groups[
ngroups] = null;
break;
}
}
if (
nthreads == 0) {
notifyAll();
}
if (
daemon && (
nthreads == 0) &&
(
nUnstartedThreads == 0) && (
ngroups == 0))
{
destroy();
}
}
}
/**
* Increments the count of unstarted threads in the thread group.
* Unstarted threads are not added to the thread group so that they
* can be collected if they are never started, but they must be
* counted so that daemon thread groups with unstarted threads in
* them are not destroyed.
*/
void
addUnstarted() {
synchronized(this) {
if (
destroyed) {
throw new
IllegalThreadStateException();
}
nUnstartedThreads++;
}
}
/**
* Adds the specified thread to this thread group.
*
* <p> Note: This method is called from both library code
* and the Virtual Machine. It is called from VM to add
* certain system threads to the system thread group.
*
* @param t
* the Thread to be added
*
* @throws IllegalThreadStateException
* if the Thread group has been destroyed
*/
void
add(
Thread t) {
synchronized (this) {
if (
destroyed) {
throw new
IllegalThreadStateException();
}
if (
threads == null) {
threads = new
Thread[4];
} else if (
nthreads ==
threads.length) {
threads =
Arrays.
copyOf(
threads,
nthreads * 2);
}
threads[
nthreads] =
t;
// This is done last so it doesn't matter in case the
// thread is killed
nthreads++;
// The thread is now a fully fledged member of the group, even
// though it may, or may not, have been started yet. It will prevent
// the group from being destroyed so the unstarted Threads count is
// decremented.
nUnstartedThreads--;
}
}
/**
* Notifies the group that the thread {@code t} has failed
* an attempt to start.
*
* <p> The state of this thread group is rolled back as if the
* attempt to start the thread has never occurred. The thread is again
* considered an unstarted member of the thread group, and a subsequent
* attempt to start the thread is permitted.
*
* @param t
* the Thread whose start method was invoked
*/
void
threadStartFailed(
Thread t) {
synchronized(this) {
remove(
t);
nUnstartedThreads++;
}
}
/**
* Notifies the group that the thread {@code t} has terminated.
*
* <p> Destroy the group if all of the following conditions are
* true: this is a daemon thread group; there are no more alive
* or unstarted threads in the group; there are no subgroups in
* this thread group.
*
* @param t
* the Thread that has terminated
*/
void
threadTerminated(
Thread t) {
synchronized (this) {
remove(
t);
if (
nthreads == 0) {
notifyAll();
}
if (
daemon && (
nthreads == 0) &&
(
nUnstartedThreads == 0) && (
ngroups == 0))
{
destroy();
}
}
}
/**
* Removes the specified Thread from this group. Invoking this method
* on a thread group that has been destroyed has no effect.
*
* @param t
* the Thread to be removed
*/
private void
remove(
Thread t) {
synchronized (this) {
if (
destroyed) {
return;
}
for (int
i = 0 ;
i <
nthreads ;
i++) {
if (
threads[
i] ==
t) {
System.
arraycopy(
threads,
i + 1,
threads,
i, --
nthreads -
i);
// Zap dangling reference to the dead thread so that
// the garbage collector will collect it.
threads[
nthreads] = null;
break;
}
}
}
}
/**
* Prints information about this thread group to the standard
* output. This method is useful only for debugging.
*
* @since JDK1.0
*/
public void
list() {
list(
System.
out, 0);
}
void
list(
PrintStream out, int
indent) {
int
ngroupsSnapshot;
ThreadGroup[]
groupsSnapshot;
synchronized (this) {
for (int
j = 0 ;
j <
indent ;
j++) {
out.
print(" ");
}
out.
println(this);
indent += 4;
for (int
i = 0 ;
i <
nthreads ;
i++) {
for (int
j = 0 ;
j <
indent ;
j++) {
out.
print(" ");
}
out.
println(
threads[
i]);
}
ngroupsSnapshot =
ngroups;
if (
groups != null) {
groupsSnapshot =
Arrays.
copyOf(
groups,
ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
for (int
i = 0 ;
i <
ngroupsSnapshot ;
i++) {
groupsSnapshot[
i].
list(
out,
indent);
}
}
/**
* Called by the Java Virtual Machine when a thread in this
* thread group stops because of an uncaught exception, and the thread
* does not have a specific {@link Thread.UncaughtExceptionHandler}
* installed.
* <p>
* The <code>uncaughtException</code> method of
* <code>ThreadGroup</code> does the following:
* <ul>
* <li>If this thread group has a parent thread group, the
* <code>uncaughtException</code> method of that parent is called
* with the same two arguments.
* <li>Otherwise, this method checks to see if there is a
* {@linkplain Thread#getDefaultUncaughtExceptionHandler default
* uncaught exception handler} installed, and if so, its
* <code>uncaughtException</code> method is called with the same
* two arguments.
* <li>Otherwise, this method determines if the <code>Throwable</code>
* argument is an instance of {@link ThreadDeath}. If so, nothing
* special is done. Otherwise, a message containing the
* thread's name, as returned from the thread's {@link
* Thread#getName getName} method, and a stack backtrace,
* using the <code>Throwable</code>'s {@link
* Throwable#printStackTrace printStackTrace} method, is
* printed to the {@linkplain System#err standard error stream}.
* </ul>
* <p>
* Applications can override this method in subclasses of
* <code>ThreadGroup</code> to provide alternative handling of
* uncaught exceptions.
*
* @param t the thread that is about to exit.
* @param e the uncaught exception.
* @since JDK1.0
*/
public void
uncaughtException(
Thread t,
Throwable e) {
if (
parent != null) {
parent.
uncaughtException(
t,
e);
} else {
Thread.
UncaughtExceptionHandler ueh =
Thread.
getDefaultUncaughtExceptionHandler();
if (
ueh != null) {
ueh.
uncaughtException(
t,
e);
} else if (!(
e instanceof
ThreadDeath)) {
System.
err.
print("Exception in thread \""
+
t.
getName() + "\" ");
e.
printStackTrace(
System.
err);
}
}
}
/**
* Used by VM to control lowmem implicit suspension.
*
* @param b boolean to allow or disallow suspension
* @return true on success
* @since JDK1.1
* @deprecated The definition of this call depends on {@link #suspend},
* which is deprecated. Further, the behavior of this call
* was never specified.
*/
@
Deprecated
public boolean
allowThreadSuspension(boolean
b) {
this.
vmAllowSuspension =
b;
if (!
b) {
VM.
unsuspendSomeThreads();
}
return true;
}
/**
* Returns a string representation of this Thread group.
*
* @return a string representation of this thread group.
* @since JDK1.0
*/
public
String toString() {
return
getClass().
getName() + "[name=" +
getName() + ",maxpri=" +
maxPriority + "]";
}
}