/**@class java.lang.ThreadGroup
 implements java.lang.Thread.UncaughtExceptionHandler

@extends java.lang.Object

 {@code ThreadGroup} is a means of organizing threads into a hierarchical structure.
 This class is obsolete. See <i>Effective Java</i> Item 73, "Avoid thread groups" for details.
 @see Thread
*/
var ThreadGroup = {

/**Returns the number of running {@code Thread}s which are children of this thread group,
 directly or indirectly.
@return {Number} the number of children
*/
activeCount : function(  ) {},

/**Returns the number of {@code ThreadGroup}s which are children of this group,
 directly or indirectly.
@return {Number} the number of children
*/
activeGroupCount : function(  ) {},

/**Does nothing. The definition of this method depends on the deprecated
 method {@link #suspend}(). The exact behavior of this call was never
 specified.
@param {Boolean} b Used to control low memory implicit suspension
@return {Boolean} {@code true} (always)
@deprecated Required deprecated method suspend().
*/
allowThreadSuspension : function(  ) {},

/**Does nothing.
*/
checkAccess : function(  ) {},

/**Destroys this thread group and recursively all its subgroups. It is only legal
 to destroy a {@code ThreadGroup} that has no threads in it. Any daemon
 {@code ThreadGroup} is destroyed automatically when it becomes empty (no threads
 or thread groups in it).
@throws IllegalThreadStateException if this thread group or any of its
         subgroups has been destroyed already or if it still contains
         threads.
*/
destroy : function(  ) {},

/**Iterates over all active threads in this group (and its sub-groups) and
 stores the threads in the given array. Returns when the array is full or
 no more threads remain, whichever happens first.

 <p>Note that this method will silently ignore any threads that don't fit in the
 supplied array.
@param {Object {java.lang.Thread[]}} threads the array into which the {@code Thread}s will be copied
@return {Number} the number of {@code Thread}s that were copied
*/
enumerate : function(  ) {},

/**Iterates over all active threads in this group (and, optionally, its
 sub-groups) and stores the threads in the given array. Returns when the
 array is full or no more threads remain, whichever happens first.

 <p>Note that this method will silently ignore any threads that don't fit in the
 supplied array.
@param {Object {java.lang.Thread[]}} threads the array into which the {@code Thread}s will be copied
@param {Boolean} recurse indicates whether {@code Thread}s in subgroups should be
        recursively copied as well
@return {Number} the number of {@code Thread}s that were copied
*/
enumerate : function(  ) {},

/**Iterates over all thread groups in this group (and its sub-groups) and
 and stores the groups in the given array. Returns when the array is full
 or no more groups remain, whichever happens first.

 <p>Note that this method will silently ignore any thread groups that don't fit in the
 supplied array.
@param {Object {java.lang.ThreadGroup[]}} groups the array into which the {@code ThreadGroup}s will be copied
@return {Number} the number of {@code ThreadGroup}s that were copied
*/
enumerate : function(  ) {},

/**Iterates over all thread groups in this group (and, optionally, its
 sub-groups) and stores the groups in the given array. Returns when
 the array is full or no more groups remain, whichever happens first.

 <p>Note that this method will silently ignore any thread groups that don't fit in the
 supplied array.
@param {Object {java.lang.ThreadGroup[]}} groups the array into which the {@code ThreadGroup}s will be copied
@param {Boolean} recurse indicates whether {@code ThreadGroup}s in subgroups should be
        recursively copied as well or not
@return {Number} the number of {@code ThreadGroup}s that were copied
*/
enumerate : function(  ) {},

/**Returns the maximum allowed priority for a {@code Thread} in this thread group.
@return {Number} the maximum priority
@see #setMaxPriority
*/
getMaxPriority : function(  ) {},

/**Returns the name of this thread group.
@return {String} the group's name
*/
getName : function(  ) {},

/**Returns this thread group's parent {@code ThreadGroup}. It can be null if this
 is the the root ThreadGroup.
@return {Object {java.lang.ThreadGroup}} the parent
*/
getParent : function(  ) {},

/**Interrupts every {@code Thread} in this group and recursively in all its
 subgroups.
@see Thread#interrupt
*/
interrupt : function(  ) {},

/**Checks whether this thread group is a daemon {@code ThreadGroup}.
@return {Boolean} true if this thread group is a daemon {@code ThreadGroup}
@see #setDaemon
@see #destroy
*/
isDaemon : function(  ) {},

/**Checks whether this thread group has already been destroyed.
@return {Boolean} true if this thread group has already been destroyed
@see #destroy
*/
isDestroyed : function(  ) {},

/**Outputs to {@code System.out} a text representation of the
 hierarchy of {@code Thread}s and {@code ThreadGroup}s in this thread group (and recursively).
 Proper indentation is used to show the nesting of groups inside groups
 and threads inside groups.
*/
list : function(  ) {},

/**Checks whether this thread group is a direct or indirect parent group of a
 given {@code ThreadGroup}.
@param {Object {ThreadGroup}} g the potential child {@code ThreadGroup}
@return {Boolean} true if this thread group is parent of {@code g}
*/
parentOf : function(  ) {},

/**Resumes every thread in this group and recursively in all its
 subgroups.
@see Thread#resume
@see #suspend
@deprecated Requires deprecated method Thread.resume().
*/
resume : function(  ) {},

/**Sets whether this is a daemon {@code ThreadGroup} or not. Daemon
 thread groups are automatically destroyed when they become empty.
@param {Boolean} isDaemon the new value
@see #isDaemon
@see #destroy
*/
setDaemon : function(  ) {},

/**Configures the maximum allowed priority for a {@code Thread} in this group and
 recursively in all its subgroups.

 <p>A caller can never increase the maximum priority of a thread group.
 Such an attempt will not result in an exception, it will
 simply leave the thread group with its current maximum priority.
@param {Number} newMax the new maximum priority to be set
@throws IllegalArgumentException if the new priority is greater than
         Thread.MAX_PRIORITY or less than Thread.MIN_PRIORITY
@see #getMaxPriority
*/
setMaxPriority : function(  ) {},

/**Stops every thread in this group and recursively in all its subgroups.
@see Thread#stop()
@see Thread#stop(Throwable)
@see ThreadDeath
@deprecated Requires deprecated method Thread.stop().
*/
stop : function(  ) {},

/**Suspends every thread in this group and recursively in all its
 subgroups.
@see Thread#suspend
@see #resume
@deprecated Requires deprecated method Thread.suspend().
*/
suspend : function(  ) {},

/**
*/
toString : function(  ) {},

/**Handles uncaught exceptions. Any uncaught exception in any {@code Thread}
 is forwarded to the thread's {@code ThreadGroup} by invoking this
 method.

 <p>New code should use {@link java.lang.Thread#setUncaughtExceptionHandler} instead of thread groups.
@param {Object {Thread}} t the Thread that terminated with an uncaught exception
@param {Object {Throwable}} e the uncaught exception itself
*/
uncaughtException : function(  ) {},


};