标签：groupsSnapshot null int ThreadGroup ngroupsSnapshot 源码 线程 groups 多线程
前言
线程组，顾名思义，就是线程的组，逻辑类似项目组，用于管理项目成员，线程组就是用来管理线程。
每个线程都会有一个线程组，如果没有设置将会有些默认的初始化设置
而在java中线程组则是使用类ThreadGroup 进行抽象描述
构造器
private ThreadGroup() {
this.name = "system"; //设置线程组名称
this.maxPriority = Thread.MAX_PRIORITY; //线程组最大优先级
this.parent = null; //父线程组为空
}
public ThreadGroup(String name) { //将线程组和线程名称传递给下面的构造器
this(Thread.currentThread().getThreadGroup(), name);
}
public ThreadGroup(ThreadGroup parent, String name) { //将信息传递给下一个构造器
this(checkParentAccess(parent), parent, name);
}
private ThreadGroup(Void unused, ThreadGroup parent, String name) {
this.name = name; //线程名称赋值
this.maxPriority = parent.maxPriority; //线程组最大优先级是父线程组的最大优先级
this.daemon = parent.daemon; //是否为守护线程，取决于父线程组
this.vmAllowSuspension = parent.vmAllowSuspension;
this.parent = parent; //父线程组
parent.add(this); //将此线程组添加到父线程组
}
属性
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[]; //线程组数组
方法
Get / Set 方法
public final String getName() { return name; } //返回线程组名称
public final ThreadGroup getParent() { if (parent != null) parent.checkAccess(); return parent; } //返回父线程组
public final int getMaxPriority() { return maxPriority; } //返回最大优先级
public final boolean isDaemon() { return daemon; } //是否为守护线程组
public synchronized boolean isDestroyed() { return destroyed; } //是否被销毁
public final void setDaemon(boolean daemon) { checkAccess(); this.daemon = daemon; } //设置是否为守护
public final boolean parentOf(ThreadGroup g) { //当前线程组 是否 为线程组g的父线程组
for (; g != null ; g = g.parent) {
if (g == this) {
return true;
}
} return false;
}
//设置最大优先级
public final void setMaxPriority(int pri) {
int ngroupsSnapshot;
ThreadGroup[] groupsSnapshot;
synchronized (this) {
checkAccess(); //权限效验
if (pri < Thread.MIN_PRIORITY || pri > Thread.MAX_PRIORITY) { //必须在范围之内
return;
}
//父线程不为空，选择参数pri和父线程组最大优先级中最小的；否则为参数pri
maxPriority = (parent != null) ? Math.min(pri, parent.maxPriority) : pri;
ngroupsSnapshot = ngroups;//线程组数赋值
if (groups != null) { //线程数组不为空
groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot); //线程组复制
} else {
groupsSnapshot = null;
}
}
//设置所有线程组最大优先级
for (int i = 0 ; i < ngroupsSnapshot ; i++) {
groupsSnapshot[i].setMaxPriority(pri);
}
}
enumerate()方法：把此线程组中的所有活动子组的引用复制到指定线程数组中。
public int enumerate(Thread list[]) {
checkAccess();
return enumerate(list, 0, true);
}
public int enumerate(Thread list[], boolean recurse) {
checkAccess();
return enumerate(list, 0, recurse);
}
private int enumerate(Thread list[], int n, boolean recurse) {
int ngroupsSnapshot = 0;
ThreadGroup[] groupsSnapshot = null;
synchronized (this) {
if (destroyed) { //如果销毁，退出
return 0;
}
int nt = nthreads;//将线程数赋值给nt
if (nt > list.length - n) { //如果nt大于它，就将其设置为它。
nt = list.length - n;
}
//将线程组中的线程，赋值给list线程集合
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;
}
enumerate()方法：把此线程组中的所有活动子组的引用复制到指定线程组数组中
public int enumerate(ThreadGroup list[]) {
checkAccess();
return enumerate(list, 0, true);
}
public int enumerate(ThreadGroup list[], boolean recurse) {
checkAccess();
return enumerate(list, 0, recurse);
}
private int enumerate(ThreadGroup list[], int n, boolean recurse) {
int ngroupsSnapshot = 0;
ThreadGroup[] groupsSnapshot = null;
synchronized (this) {
if (destroyed) {
return 0;
}
int ng = ngroups;
if (ng > list.length - n) {
ng = list.length - n;
}
if (ng > 0) {
System.arraycopy(groups, 0, list, n, ng);
n += ng;
}
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;
}
统计活动线程/线程组估计数
//活动线程估计数
public int activeCount() {
int result;
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;
}
//活动线程组的估计数
public int activeGroupCount() {
int ngroupsSnapshot;
ThreadGroup[] groupsSnapshot;
synchronized (this) {
if (destroyed) {
return 0;
}
ngroupsSnapshot = ngroups;
if (groups != null) {
groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
int n = ngroupsSnapshot;
for (int i = 0 ; i < ngroupsSnapshot ; i++) {
n += groupsSnapshot[i].activeGroupCount();
}
return n;
}
interrupt() 中断线程组中所有线程
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 = Arrays.copyOf(groups, ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
//循环中断包含的所有线程组中的线程
for (int i = 0 ; i < ngroupsSnapshot ; i++) {
groupsSnapshot[i].interrupt();
}
}
destory() 销毁此线程组及其所有子组。
public final void destroy() {
int ngroupsSnapshot;
ThreadGroup[] groupsSnapshot;
synchronized (this) {
checkAccess();
if (destroyed || (nthreads > 0)) { //如果当前线程已销毁 或 当前线程组内还有线程 抛出异常.
throw new IllegalThreadStateException();
}
ngroupsSnapshot = ngroups; //线程组数
if (groups != null) {
groupsSnapshot = Arrays.copyOf(groups, 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);
}
}
add() 将指定的线程组添加到此组。
private final void add(ThreadGroup g){
synchronized (this) {
if (destroyed) {
throw new IllegalThreadStateException();
}
if (groups == null) { //线程组数组为空，新建长度为4
groups = new ThreadGroup[4];
} else if (ngroups == groups.length) { //不为空，扩容2倍
groups = Arrays.copyOf(groups, ngroups * 2);
}
groups[ngroups] = g;
ngroups++; //线程组数量自增1
}
}
remove() 从该组中移除指定的线程组。
private void remove(ThreadGroup g) {
synchronized (this) {
if (destroyed) {
return;
}
for (int i = 0 ; i < ngroups ; i++) {
//循环找到线程组中指定的线程，进行移除操作
if (groups[i] == g) {
ngroups -= 1;
System.arraycopy(groups, i + 1, groups, i, ngroups - i);
groups[ngroups] = null;
break;
}
}
//如果当前线程组内无线程，唤醒其他所有线程
if (nthreads == 0) {
notifyAll();
}
//此线程组啥都没有了，就销毁
if (daemon && (nthreads == 0) &&
(nUnstartedThreads == 0) && (ngroups == 0))
{
destroy();
}
}
}
end
还有一些方法没有介绍到，可以结合源码进行详细学习。
标签：groupsSnapshot,null,int,ThreadGroup,ngroupsSnapshot,源码,线程,groups,多线程 来源： https://www.cnblogs.com/FondWang/p/12100517.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。