I have tried mightily to resist the urge to redesign as I document,
but in the area of threads and groups I find the "enumerate" mess
sufficiently weird that I would like to propose replacement functionality:

Deprecate:	enumerate, activeCount, activeGroupCount from ThreadGroup
	enumerate, activeCount from Thread

To ThreadGroup add:
	int threadsCount()
	int allThreadsCount()		// equals activeCount
	int groupsCount()
	int allGroupsCount()		// equals activeGroupCount
	Thread[] threads()
	ThreadGroup[] groups()
	Thread[] allThreads()
	ThreadGroup[] allGroups()

Eight methods, each of no arguments, with three orthogonal attributes:
	"threads" deals with threads, "groups" with thread groups
	"all" means a recursive search, otherwise just immediate ones
	"count" means returns an int, otherwise return an array of them

James says he likes this.

Here is the proposed code.  Yes, I am aware that allThreads and allGroups
may have execution time quadratic in the number of threads.  I don't think
it matters in practice---if it does, eventually we can substitute a more
clever algorithm.

--Guy


    public synchronized int threadsCount() {
	return nthreads;
    }

    public synchronized int allThreadsCount() {
	int n = nthreads;
	for (int i = 0 ; i < ngroups ; i++) {
	    n += groups[i].activeCount();
	}
	return n;
    }

    public synchronized int groupsCount() {
	return ngroups;
    }

    public synchronized int allGroupsCount() {
	int n = ngroups;
	for (int i = 0 ; i < ngroups ; i++) {
	    n += groups[i].activeGroupCount();
	}
	return n;
    }

    private Thread[] emptyThreadsArray = new Thread[0];

    public synchronized Thread[] threads() {
	if (nthreads == 0)
	    return emptyThreadsArray;
	Thread[] result = new Thread[nthreads];
	System.arraycopy(threads, 0, result, 0, nthreads);
	return result;
    }

    public synchronized Thread[] allThreads() {
	Thread[] result = threads();
	for (int i = 0 ; i < ngroups ; i++) {
	    Thread[] more = groups[i].allThreads();
	    if (more.length != 0) {
		if (result.length == 0)
		    result = more;
		else {
		    Thread[] concat = new Thread[result.length + more.length];
		    System.arraycopy(result, 0, concat, 0, result.length);
		    System.arraycopy(more, 0, concat, result.length, more.length);
		    result = concat;
		}
	    }
	}
	return result;
    }

    private ThreadGroup[] emptyGroupsArray = new ThreadGroup[0];

    public synchronized ThreadGroup[] groups() {
	if (ngroups == 0)
	    return emptyGroupsArray;
	ThreadGroup[] result = new ThreadGroup[ngroups];
	System.arraycopy(groups, 0, result, 0, ngroups);
	return result;
    }

    public synchronized ThreadGroup[] allGroups() {
	ThreadGroup[] result = groups();
	for (int i = 0 ; i < ngroups ; i++) {
	    ThreadGroup[] more = groups[i].allGroups();
	    if (more.length != 0) {
		if (result.length == 0)
		    result = more;
		else {
		    ThreadGroup[] concat = new ThreadGroup[result.length + more.length];
		    System.arraycopy(result, 0, concat, 0, result.length);
		    System.arraycopy(more, 0, concat, result.length, more.length);
		    result = concat;
		}
	    }
	}
	return result;
    }