java--ThreadGroup详解

简介

ThreadGroup（线程组）是Java中用于组织线程的一种结构，它提供了对线程的层次化管理。通过线程组，可以将一组线程组织成一个树状结构，方便对线程进行统一控制和管理。

ThreadGroup的一些主要特点和用法：

层次结构：线程组能够形成层次结构，具有父子关系。每个线程组都有一个父线程组，除了主线程组（默认的顶级线程组）外。通过层次结构，可以方便地对整个线程组进行组织和管理。
统一控制： 通过线程组，可以对整个线程组的属性进行统一的控制，如设置线程组的优先级、守护状态（daemon）、未捕获异常处理器（uncaught exception handler）等。这些设置会自动应用于该线程组中的所有线程。
异常处理： 线程组可以设置一个统一的未捕获异常处理器，用于处理线程组中的线程产生的未捕获异常。这可以有效地集中处理线程组中的异常情况。
线程组的活动监控：ThreadGroup类还提供了一些方法来获取有关线程组中线程的信息，如活动线程数、子线程组数等

线程组的基本使用

创建线程组将两个线程放入到线程组中

csharp 复制代码

package Future类;

public class demo333 {
    public static void main(String[] args) {
        ThreadGroup group= new ThreadGroup("线程组");
        Thread t1=new Thread(group,new myrun(),"线程1");
        Thread t2=new Thread(group,new myrun(),"线程2");
        t1.start();
        t2.start();

        System.out.println("Number of active threads in the group: " + group.activeCount());
        System.out.println("Thread group name: " + group.getName());

        group.list();

    }
}
class myrun implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"running了");
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + " is completed.");
    }
}

运行结果：

Number of active threads in the group: 2 线程1running了 Thread group name: 线程组线程2running了 java.lang.ThreadGroup $name=线程组,maxpri=10$ Thread $线程1,5,线程组$ Thread $线程2,5,线程组$ 线程1 is completed. 线程2 is completed.

通过activeCount()方法和getName()方法，可以获取线程组中活动线程的数量和线程组的名称

通过list()方法，可以在控制台上列出线程组中的线程和线程组的信息

线程池中使用线程组

线程组可以帮助我们管理相关联的线程，进行统一的控制和管理。特别适合用于对一组线程进行集中管理的场景，例如线程池任务中的线程归类、通过异常处理器处理一组线程中的异常等

结合线程池使用线程组可以更好地管理和控制线程的执行。线程池可以提供线程的重用和资源管理，而线程组可以提供对线程的蹭层次化组织和管理；下面是结合线程池使用线程组的举例：

java 复制代码

package Future类;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

public class dmmo444 {
    public static void main(String[] args) {
        ThreadGroup group=new ThreadGroup("myThreadgroup");
        ExecutorService executorService= Executors.newFixedThreadPool(2,new ThreadFactoryWithThreadGroup(group));

        executorService.execute(new myruns("tesk1"));
        executorService.execute(new myruns("tesk2"));
        executorService.execute(new myruns("tesk3"));

        executorService.shutdown();
    }
}
class myruns implements Runnable{

    private String name;

    public myruns(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("Executing name"+name+",线程组的名字为"+Thread.currentThread().getThreadGroup().getName());
        //添加具体执行的操作
    }
}
class ThreadFactoryWithThreadGroup implements ThreadFactory{
    private ThreadGroup threadGroup;

    public ThreadFactoryWithThreadGroup(ThreadGroup threadGroup) {
        this.threadGroup = threadGroup;
    }

    @Override
    public Thread newThread(Runnable r) {
        return new Thread(threadGroup,r);
    }
}

运行结果：

Executing nametesk1,线程组的名字为myThreadgroup Executing nametesk2,线程组的名字为myThreadgroup Executing nametesk3,线程组的名字为myThreadgroup

我们创建了一个包含两个线程的线程池，并且为线程池指定了一个自定义的ThreadFactory（线程工厂），该工厂类使用线程组作为线程的创建者。

在主线程中，我们创建了一个名为"MyThreadGroup"的线程组，并为线程池提供了该线程组的实例。

然后，我们向线程池提交了三个Runnable任务，并通过不同的线程执行。在任务的run()方法中，我们可以看到线程所属的线程组名字是"MyThreadGroup"

通过结合线程池和线程组的使用，我们可以更好地管理和控制线程的创建、执行和销毁。线程池提供了线程的重用和资源管理，而线程组提供了对线程的组织和管理能力。这种结合使用可以更好地满足多线程编程中的需求，减少了对线程的手动维护，