/**
* 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.
*/
//此方法通常用于创建一个空的线程组,且其不位于任何已存在的线程组中;
//一般将该方法用于创建:“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
*/
//这比上一个构造器多了一个 ThreadGroup parent 的规定,实际上其就是一个规定了线程组名字以及父线程组的线程组对象构造器。
//上一个构造器实际上调用了下面这个构造器。
//checkAccess方法用于检测线程组变量parent是否为空,空则抛出异常。
public ThreadGroup(ThreadGroup parent, String name) {
this(checkParentAccess(parent), parent, name);
}
//这个方法就是私有的构造器,本质上其余public构造器都调用了这个方法。
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.
*/
//这就是上述构造器中所有使用私有checkParentAcces方法,当parent对象为空时,那么会抛出空指针异常:NullPointerException
//如果当前线程不能在特定的线程组中不能创建一个线程,那么就会抛出安全异常:SecurityException
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
*/
//此方法用于返回当前线程组的父线程组;
//如果当前线程组对象的父线程为空,那么直接返回null,如果当前线程组对象的父线程不为空,
//但是当前线程组不能修改这个线程组,那么可能会返回SecurityException
//其余情况则是正常返回当前线程所在的线程组的父线程组
//注意:只有最顶层的线程组调用此方法才会返回null;
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
*/
//此方法用于将调用此放的线程组对象按照输入的daemon值来改变其是否为守护线程组的状态。
//true:认为其为守护线程组,否则亦反
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
*/
//此方法还是用于设置当前线程组的最大优先级,而且不影响其内部已经高于此优先级的线程属性。
//如果目标优先级设置值:pri的值比组内最大的优先级都大,或者比组内最小的优先级都小,那么
//则不会改变当前线程组的最大优先级。
//在其他情况下,当前线程组对象的优先级会被设置为输入值pri以及其父线程组的优先级最大值中的较小值。
//如果当前线程组就是system thread group,没有父线程组,那么直接就将当前线程组最大优先级设置为pri
//如果对一个线程组设置最大优先级完成,那么就会使其所属的所有子线程组递归调用此方法,所以
//最终会导致一个详细,父线程组的优先级总是高于子线程组的优先级。
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
*/
//检测当前方法调用的线程组对象是否为输入线程组对象的祖先线程组。
//注意,如果输入线程组对象为空,那么直接返回false;
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
*/
//将当前线程组以及其子线程组(子子孙孙线程组)中所有活跃的线程拷贝到所规定的数组对象Thread list[]中;
//一个线程组对应一个list对象。
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);
}
//此方法就是上两个方法的目方法,但是其被设置为私有的,上面两个方法都将n设置为0,这是为了将所有线程组的所有线程都考虑进内;
//recurse控制着是否将当前线程组的子线程组(子子孙孙线程组)中的线程是否也纳入活跃线程的统计。
//如果线程数量过多,放不进Thread list[]数组对象,那么就会把放不下的忽略掉。
//如果想要一个准确的数组统计,那么应该进行活跃线程的估计,提供一个合适大小的Thread list[]对象
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
*/
//此方法用于返回当前线程组对象以及其子线程组(子子孙孙线程组)对象的活跃线程组数目的估计值。
//这个返回值只是一个估计值,这是因为活跃线程组数量在这个方法在执行遍内部数据结构的遍历过程中就会动态变化.这个方法应当仅仅用于debug以及监控器。
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
*/
//此处是将当前线程组及其子子孙孙线程组中活跃的线程组一并拷贝到输入数组ThreadGroup list[]中。
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
*/
//类似于拷活跃线程于数组中,这里是拷贝活跃线程组于数组中,实现方法几乎一样。
//并且其用途也是仅仅用于debug,以及监控器。
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.
*/
//这是一个被弃用的方法,其功能是关闭当前线程组中所有执行的线程。
//类似地,需要现先判断当前线程是否对线程组有访问或刘该的权力。
//但是遍历关线程所调用的方法Thread.currentThread().stop();本身就是被弃用的。
@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
*/
//这是一个用来摧毁一个线程组的方法。但是线程组必须得为空,也就是说该线程组中的所有线程以及全部关闭了。
//如果此线程组非空或者以及被摧毁了,那么此方法就会抛出IllegalThreadStateException异常;
//如果此当前线程效用此线程组对象的此方法,但是当前线程没有权限修改此线程组,那么抛出SecurityException异常。
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.
*/
//此方法用于将输入线程组对象添加到当前线程组中。
//如果当前线程组已经被摧毁,那么抛出IllegalThreadStateException异常。
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
*/
//告诉当前线程组线程t终止了。
//如果此线程组是守护线程组,并且没有活跃的线程和未启动的线程,也没有子线程组,在满足这四个条件下,
//线程组会被摧毁。
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
*/
//以一定标准打印出当前线程组的信息。这个方法只有在debug过程中有用。
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
*/
//如果当前线程组被意外停止了,那么JVM就会调用这个方法。
//此方法抛出的异常:uncaughtException,中文名为未捕获异常。
//JVM默认不提供未捕获异常的处理器:UncaughtExceptionHandler,不过继承于ThreadGroup的子类可以重写此方法,
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 + "]";
}