ThreadGroup 源码解析

ThreadGroup 实现了Thread.UncaughtExceptionHandler

内部定义的变量为

    //父类ThreadGroup
    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[];

构造函数

public ThreadGroup(ThreadGroup parent, String name) {
        this(checkParentAccess(parent), parent, name);
}

checkParentAccess的方法

private static Void checkParentAccess(ThreadGroup parent) {
        parent.checkAccess();
        return null;
    }

checkAccess方法

 public final void checkAccess() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkAccess(this);
        }
    }

 

setMaxPriority(int pri)设置最高优先级方法

public final void setMaxPriority(int pri) {
        int ngroupsSnapshot;
        ThreadGroup[] groupsSnapshot;
        synchronized (this) {
            //首先检查安全性
            checkAccess();
            //如果安全级别在小于min大于max则最高等级保持不变
            if (pri < Thread.MIN_PRIORITY || pri > Thread.MAX_PRIORITY) {
                return;
            }
            //最高优先级为父线程组优先级，若父优先级更小
            maxPriority = (parent != null) ? Math.min(pri, parent.maxPriority) : pri;
            ngroupsSnapshot = ngroups;
            if (groups != null) {
                //复制groups到groupsSnapshot
                groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
            } else {
                groupsSnapshot = null;
            }
        }
        //递归设置每个线程组的最高优先级
        for (int i = 0 ; i < ngroupsSnapshot ; i++) {
            groupsSnapshot[i].setMaxPriority(pri);
        }
    }

activeCount() 活动线程的估计数

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;
    }

enumerate 把对此线程组中的所有活动子组的引用复制到指定数组中。

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;
    }