线程组

萌宠菠菠乐园
2024-10-09 14:26

线程组有两个构造方法

public ThreadGroup(String name);传入线程组的名字并构造线程组，其父线程组是创建此线程组的线程所在的线程组

public ThreadGroup(ThreadGroup parent,String name);该构造函数需要传入两个参数，第一个参数是父线程组，另一个参数是当前线程组的名字；

获得当前线程的所在线程组的方法即线程组属性的获取

getThreadGroup();可以获得当前线程所在线程组；getName()；返回当前线程组的名字；activeCount()；返回当前线程组的活跃线程数，包括其子线程组的；

复制Thread数组；

复制线程数组有两种方法：
public int enumerate(Thread[] list);将调用该方法的线程组（包括其子线程组）的活跃线程写入listThread数组中，返回到的int是该线程组的活跃线程数，包括子线程组的活跃线程。
public int enumerate(Thread[] list,boolean recurse):当第二个参数为true的时候与上一个方法一样的效果，当第二个参数为false的时候，不会包括其子线程组的线程，返回到的int是该线程组的活跃线程数，不包括包括子线程组的，你如下面例子中与前两个相比返回就少1；

public class text {public static void main(String[] args) throws IOException, InterruptedException {ThreadGroup mianGroup = Thread.currentThread().getThreadGroup();// 获取到组线程的线程组Thread t1 = new Thread(mianGroup, () -> {try {mythread.sleep(1);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}, "t1");t1.start();ThreadGroup group1 = new ThreadGroup(mianGroup, "group1");// 新建一个位于main线程组下的线程组Thread t2 = new Thread(group1, () -> {try {mythread.sleep(1);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}, "t2");t2.start();Thread[] list1 = new Thread[mianGroup.activeCount()];// activeCout()方法可以获取线程组的活跃线程数// 获取main线程组下及其子线程组的所有活跃线程int a1 = mianGroup.enumerate(list1);System.out.println("一个参数");System.out.println("enemerate返回" + a1);for (Thread a : list1) {System.out.println(a);}System.out.println("两个参数，true");Thread[] list2 = new Thread[mianGroup.activeCount()];int a2 = mianGroup.enumerate(list2, true);System.out.println("enemerate返回" + a2);for (Thread a : list2) {System.out.println(a);}System.out.println("两个参数，false");Thread[] list3 = new Thread[mianGroup.activeCount()];int a3 = mianGroup.enumerate(list3, false);System.out.println("enemerate返回" + a3);for (Thread a : list3) {System.out.println(a);}} }

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253

输出：
一个参数
enemerate返回3
Thread[main,5,main]
Thread[t1,5,main]
Thread[t2,5,group1]
两个参数，true
enemerate返回3
Thread[main,5,main]
Thread[t1,5,main]
Thread[t2,5,group1]
两个参数，false
enemerate返回2
Thread[main,5,main]
Thread[t1,5,main]
null

复制ThreadGroup数组：

public int enumerate(ThreadGroup[] list);j将该线程组的子线程组包括子线程组的线程组返回到list中，并且返回此线程组的活跃子线程组，（递归）public int enumerate(ThreadGroup[] list,boolean recures);只能将该线程组的直接子线程组，不能递归，返回直接活跃子线程组的数量

public class text {public static void main(String[] args) throws IOException, InterruptedException {ThreadGroup mianGroup = Thread.currentThread().getThreadGroup();// 获取到组线程的线程组ThreadGroup Group1=new ThreadGroup(mianGroup,"t1");ThreadGroup Group2=new ThreadGroup(Group1,"t2");ThreadGroup[] list1=new ThreadGroup[mianGroup.activeGroupCount()];System.out.println("单个参数");int a1=mianGroup.enumerate(list1);System.out.println(a1);for(ThreadGroup a:list1) {System.out.println(a);}System.out.println("多参数,true");ThreadGroup[] list2=new ThreadGroup[mianGroup.activeGroupCount()];int a2=mianGroup.enumerate(list2,true);System.out.println(a2);for(ThreadGroup a:list2) {System.out.println(a);}System.out.println("多参数，false");ThreadGroup[] list3=new ThreadGroup[mianGroup.activeGroupCount()];int a3=mianGroup.enumerate(list3,false);System.out.println(a3);for(ThreadGroup a:list3) {System.out.println(a);}} }

123456789101112131415161718192021222324252627282930

输出：
单个参数
2
java.lang.ThreadGroup[name=t1,maxpri=10]
java.lang.ThreadGroup[name=t2,maxpri=10]
多参数,true
2
java.lang.ThreadGroup[name=t1,maxpri=10]
java.lang.ThreadGroup[name=t2,maxpri=10]
多参数，false
1
java.lang.ThreadGroup[name=t1,maxpri=10]
null //为null的原因是：activeGroupCout返回的是所有活跃子线 . 程组的数量，多层，递归式

线程组的主要方法

线程组的主要作用是对线程进行组织

activeCount();用于返回线程组中活跃的线程数量，不能百分百保证数据返回一定正确activeGroupCount()；用于返回线程组中活跃的子线程组数量，也是一个估计值，不能保证一定正确getMaxPriority()；用于获取线程组的优先级，最大为10，线程组里面的线程的优先级不能大于线程组的优先级getName()；获取线程组的名字getParent()；获取该线程组的父线程组，如果没有则返回nulllist()；该方法会将线程组的所有线程信息以及线程组信息输出到控制台；不仅仅时活跃的boolean parentOf(ThreadGroup g)；会判断当前线程组是不是参数线程组的父线程组，如果参数是本身，那么也返回truesetMaxPriority(int pri)；设置该线程的最大优先级，其最大优先级不能超过父类的最大优先级，并且设置后也会改变所有子类的最大优先级。

线程组的interrupt

interrupt一个线程组会导致该线程组的所有active的线程都被interrupt;也就是说每个活跃的线程的interrupt标识都被设置了

public class text {public static void main(String[] args) throws IOException, InterruptedException {ThreadGroup group = new ThreadGroup("group");Thread t = new Thread(group, () -> {try {mythread.sleep(2);} catch (InterruptedException e) {// TODO Auto-generated catch blockSystem.out.println("t will be exit");}}, "t");t.start();Thread.sleep(2);group.interrupt();} }

123456789101112131415161718

输出：t will be exit

线程组的destroy

用于销毁线程组，但是只是针对一个没有活跃线程的线程组进行一次标记，调用该方法的直接结果是在父线程组中将自己删除，包括其子线程组

public class text {public static void main(String[] args) throws IOException, InterruptedException {ThreadGroup mainGroup=Thread.currentThread().getThreadGroup();ThreadGroup group1=new ThreadGroup("group1");ThreadGroup group2=new ThreadGroup(group1,"group2");mainGroup.list();System.out.println("摧毁group1线程");group1.destroy();mainGroup.list();} } 1234567891011

输出：
java.lang.ThreadGroup[name=main,maxpri=10]
Thread[main,5,main]
java.lang.ThreadGroup[name=group1,maxpri=10]
java.lang.ThreadGroup[name=group2,maxpri=10]
摧毁group1线程
java.lang.ThreadGroup[name=main,maxpri=10]
Thread[main,5,main]

守护ThreadGroup

线程组也可以设置为守护线程组，将一个线程组设为守护，它不会影响其线程的性能，当该线程组没有一个活跃线程的时候，线程组将被自动摧毁

public class text {public static void main(String[] args) throws IOException, InterruptedException {ThreadGroup mainGroup=Thread.currentThread().getThreadGroup();ThreadGroup group1 = new ThreadGroup("group1");group1.setDaemon(true);Thread thread = new Thread(group1, () -> {try {Thread.sleep(1);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}, "thread");thread.start();Thread.sleep(10);mainGroup.list();} }

123456789101112131415161718

输出：
java.lang.ThreadGroup[name=main,maxpri=10]
Thread[main,5,main]
只包含了主线程和主线程组；

补充：一个线程如何才能被称作active?

我的理解是，start开始后直到该线程执行结束之气那都叫active，线程死亡后才不是active。下面的线程确实检测了一个线程start之后和死亡之前都是胡月线程的状态，但是由于技术原样并没有检测阻塞状态是不是活跃线程状态，但是我初步判定应该属于活跃状态

public class text {public static void Copy(ThreadGroup group) {Thread[] list = new Thread[group.activeCount()];group.enumerate(list);System.out.println("----");for (Thread a : list) {System.out.println(a);}System.out.println("----");}public static void main(String[] args) throws IOException, InterruptedException {// 线程活跃的检测；ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();Thread thread = new Thread(mainGroup, () -> {for (int i = 0; i <= 10; i++) {System.out.println(i);if (i == 5)Copy(mainGroup);}}, "thread");System.out.println("启动前的活跃数组");Copy(mainGroup);System.out.println("现在要启动线程");thread.start();System.out.println("启动后活跃线程的检测");Copy(mainGroup);while (true) {if (thread.isAlive() == false) {System.out.println("thread线程已经死亡");Copy(mainGroup);break;}}} } --------------------------------------------------------- 输出启动前的活跃数组 ---- Thread[main,5,main] ---- 现在要启动线程启动后活跃线程的检测 ---- Thread[main,5,main] Thread[thread,5,main] ---- 0 1 2 3 4 5 ---- Thread[main,5,main] Thread[thread,5,main] ---- 6 7 8 9 10 thread线程已经死亡 ---- Thread[main,5,main] ----

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970