ThreadGroup
ThreadGroup树形结构解析
线程Thread和线程组ThreadGroup的关系
1.线程Thread
多线程机制是由java虚拟机支持的，线程是实际计算任务的载体，由java虚拟机执行，用户往往创建新的线程来进行异步处理。java虚拟机需要线程存在，才能真正为用户工作。
2.线程组ThreadGroup
为线程服务，用户通过使用线程组的概念批量管理线程，如批量停止或挂起等。
3.线程和线程组的关系
每个线程创建时，都会纳入线程组的树形结构
4.关于线程组的思考
我们在管理一组对象时往往只是使用数组列表，树形结构的引入解决什么问题，给我们带来什么便利
线程组树形结构
树形结构如上图，一个线程或线程组创建时，必须要获知它的父线程组,一个线程必须要属于某一个线程组。
树形结构的代码实现
1.根节点唯一性
即system TheadGroup,需要确保它的唯一性
ThreadGroup.java
static final ThreadGroup systemThreadGroup = new ThreadGroup();
使用静态变量，确保全局只有一个对象
2.添加线程节点Thread
需要先计算出它的父线程组，然后把它加入父线程组。每个父线程组维护一个数组Threads[]，来保存它的子线程。
计算父线程组有两种方式：
指定父线程组
Thread.java
public Thread(ThreadGroup group, Runnable target) {
init(group, target, "Thread-" + nextThreadNum(), 0);
}
或者使用缺省父线程组 parent.getThreadGroup()
Thread.java
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
Thread parent = currentThread();
if (g == null) {
g = parent.getThreadGroup();
}
//新线程继承父线程组的优先级
this.target = target;
this.priority = parent.getPriority();
this.daemon = parent.isDaemon();
...
}
线程节点的增加
ThreadGroup.java
Thread threads[];
void add(Thread t) {
//自动扩展
if (threads == null) {
threads = new Thread[4];
} else if (nthreads == threads.length) {
threads = Arrays.copyOf(threads, nthreads * 2);
}
//添加节点到threads[]
threads[nthreads] = t;
...
}
threads[]数组实现了自动扩展，因为它无法确定子线程节点有多少。
threads[]的初始长度是4，如果满了，就以2倍速度扩展，8，16，…
3.添加线程组节点ThreadGroup
需要计算其父线程组节点，然后父线程组纳入此节点。每个父线程组通过维护groups[]，来保存它的子线程组节点。
ThreadGroup.java
ThreadGroup groups[];
private final void add(ThreadGroup g){
//实现groups数组的自动扩展
if (groups == null) {
groups = new ThreadGroup[4];
} else if (ngroups == groups.length) {
groups = Arrays.copyOf(groups, ngroups * 2);
}
//添加节点到groups[]
groups[ngroups] = g;
}
4.移除子线程节点或子线程组节点
子线程节点和子线程组节点的移除操作一致，不同的是操作的列表不同，子线程节点操作的是threads[],而子线程组节点操作的是groups[]。这里只以子线程节点为例。
ThreadGroup.java
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;
}
}
}
}
首先要先理解System.arraycopy函数的基本用法
System.java
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
其中，src表示源数组，srcPos表示源数组要复制的起始位置，desc表示目标数组，length表示要复制的长度。
具体可以参考以下博客：
System.arraycopy()方法详解
可以看到，arraycopy是一种浅复制，但此处却利用它实现了数组的删除。举个例子，已知thread[]有A，B，C，D子线程节点，现在要删除B节点。
如以下图所示：
巧妙地通过sytem.arraycopy，自身列表对自身列表的复制操作，实现删除。很简洁。
5.集合操作时的递归遍历
可以说，树形结构为集合操作提供很简洁的形式，就是支持递归遍历。举个例子
ThreadGroup.java
public final void interrupt() {
int ngroupsSnapshot;
ThreadGroup[] groupsSnapshot;
synchronized (this) {
checkAccess();
//thread遍历
for (int i = 0 ; i < nthreads ; i++) {
threads[i].interrupt();
}
ngroupsSnapshot = ngroups;
if (groups != null) {
groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
//threadGroup递归遍历
for (int i = 0 ; i < ngroupsSnapshot ; i++) {
groupsSnapshot[i].interrupt();
}
}
第一部分，是对thread子节点直接使用for循环进行遍历。
第二部分，对threadGroup子节点调用本函数，递归遍历。
小结
threadGroup通过把各个thread组织成树形结构，新的thread创建时会默认继承父线程组的优先级，对于批量处理thread有更加细致的操作选择，满足用户更多的批量处理需求。