/** * 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 = new ThreadGroup[ngroupsSnapshot]; System.arraycopy(groups, 0, groupsSnapshot, 0, 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); } }
/** * 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) { if (parent == null) { throw new NullPointerException(); } parent.checkAccess(); this.name = name; this.maxPriority = parent.maxPriority; this.daemon = parent.daemon; this.vmAllowSuspension = parent.vmAllowSuspension; this.parent = parent; parent.add(this); saveThreadStarterClassFlag = parent.saveThreadStarterClassFlag; }
/** * 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 = new ThreadGroup[ngroupsSnapshot]; System.arraycopy(groups, 0, groupsSnapshot, 0, ngroupsSnapshot); } else { groupsSnapshot = null; } } for (int i = 0; i < ngroupsSnapshot; i++) { groupsSnapshot[i].interrupt(); } }
/** * 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) { maxPriority = Thread.MIN_PRIORITY; } else if (pri < maxPriority) { maxPriority = pri; } ngroupsSnapshot = ngroups; if (groups != null) { groupsSnapshot = new ThreadGroup[ngroupsSnapshot]; System.arraycopy(groups, 0, groupsSnapshot, 0, ngroupsSnapshot); } else { groupsSnapshot = null; } } for (int i = 0; i < ngroupsSnapshot; i++) { groupsSnapshot[i].setMaxPriority(pri); } }
/** * Copies into the specified array references to every active subgroup in this thread group. If * the <code>recurse</code> flag is <code>true</code>, references to all active subgroups of the * subgroups and so forth are also included. * * <p>First, the <code>checkAccess</code> method of this thread group is called with no arguments; * this may result in a security exception. * * <p>An application should use the <code>activeGroupCount</code> method to get an estimate of how * big the array should be. * * @param list an array into which to place the list of threads. * @param recurse a flag indicating whether to recursively enumerate all included thread groups. * @return the number of thread groups put into the array. * @exception SecurityException if the current thread does not have permission to enumerate this * thread group. * @see java.lang.ThreadGroup#activeGroupCount() * @see java.lang.ThreadGroup#checkAccess() * @since JDK1.0 */ public int enumerate(ThreadGroup list[], boolean recurse) { checkAccess(); return enumerate(list, 0, recurse); }
/** * Copies into the specified array references to every active subgroup 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>An application should use the <code>activeGroupCount</code> method to get an estimate of how * big the array should be. If the array is too short to hold all the thread groups, the extra * thread groups are silently ignored. * * @param list an array into which to place the list of thread groups. * @return the number of thread groups put into the array. * @exception SecurityException if the current thread does not have permission to enumerate this * thread group. * @see java.lang.ThreadGroup#activeGroupCount() * @see java.lang.ThreadGroup#checkAccess() * @since JDK1.0 */ public int enumerate(ThreadGroup list[]) { checkAccess(); return enumerate(list, 0, true); }
/** * 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; }
/** * 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; }