Java Java类

ThreadGroup 创建一组线程。它提供了一种将线程组作为一个单元进行管理的便捷方式。这在您想要暂停和恢复许多相关线程的情况下特别有价值。

线程组形成一棵树，其中除了初始线程组之外的每个线程组都有一个父线程组。
允许线程访问有关其自己的线程组的信息，但不能访问有关其线程组的父线程组或任何其他线程组的信息。

构造函数：

public ThreadGroup(String name)：构造一个新的线程组。这个新组的父组是当前运行线程的线程组。
```
Throws: SecurityException - if the current thread cannot
 create a thread in the specified thread group.
```

public ThreadGroup(ThreadGroup parent, String name)：创建一个新的线程组。这个新组的父级是指定的线程组。

Throws: 
NullPointerException - if the thread group argument is null.
SecurityException - if the current thread cannot create a thread in the 
specified thread group.

方法

int activeCount()：此方法返回组中的线程数以及该线程为其父的任何组。

Syntax: public int activeCount()
Returns: This method returns an estimate of the number of 
active threads in this thread group and in any other thread group 
that has this thread group as an ancestor.
Exception: NA

// Java code illustrating activeCount() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 1000; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
                System.out.println("Exception encounterted");
            }
        }
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[])
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("parent thread group");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting one");
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting two");
  
        // checking the number of active thread
        System.out.println("number of active thread: "
                           + gfg.activeCount());
    }
}

输出：

Starting one
Starting two
number of active thread: 2

int activeGroupCount()：此方法返回此线程组中活动组的估计数。

Syntax: public int activeGroupCount().
Returns: Returns the number of groups for which the invoking thread is parent.
Exception: NA.

// Java code illustrating activeGroupCount() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 1000; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
                System.out.println("Exception encounterted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
            " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("gfg");
  
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting one");
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting two");
  
        // checking the number of active thread
        System.out.println("number of active thread group: "
                           + gfg.activeGroupCount());
    }
}

输出：

Starting one
Starting two
number of active thread group: 2
one finished executing
two finished executing

void checkAccess()：使安全管理器验证调用线程可以访问和/或更改调用checkAccess()的组。

Syntax: final void checkAccess().
Returns: NA.
Exception: NA.

// Java code illustrating checkAccess() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 1000; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
                System.out.println("Exception encounterted");
            }
        }
        System.out.println(Thread.currentThread().getName() +
              " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
  
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting one");
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting two");
        gfg.checkAccess();
        System.out.println(gfg.getName() + " has access");
        gfg_child.checkAccess();
        System.out.println(gfg_child.getName() + " has access");
    }
}

输出：

Starting one
Starting two
Parent thread has access
child thread has access
one finished executing 
two finished executing

void destroy()：销毁线程组和调用它的任何子组。

Syntax: public void destroy().
Returns: NA.
Exception: 
IllegalThreadStateException - if the thread group is not 
empty or if the thread group has already been destroyed.
SecurityException - if the current thread cannot modify this thread group.

// Java code illustrating destroy() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
                System.out.println("Exception encounterted");
            }
        }
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
  
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting one");
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting two");
  
        // block until other thread is finished
        t1.join();
        t2.join();
  
        // destroying child thread
        gfg_child.destroy();
        System.out.println(gfg_child.getName() + " destroyed");
  
        // destroying parent thread
        gfg.destroy();
        System.out.println(gfg.getName() + " destroyed");
    }
}

输出：

Starting one
Starting two
child thread destroyed
Parent thread destroyed

int enumerate(Thread group[])：将构成调用线程组的线程放入组数组中。

Syntax: public int enumerate(Thread group[]).
Returns: the number of threads put into the array.
Exception: SecurityException - if the current thread 
does not have permission to enumerate this thread group.

// Java code illustrating enumerate() method.
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) {
                System.out.println("Exception encounterted");
            }
        }
        System.out.println(Thread.currentThread().getName() +
             " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
  
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting one");
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting two");
  
        // returns the number of threads put into the array
        Thread[] group = new Thread[gfg.activeCount()];
        int count = gfg.enumerate(group);
        for (int i = 0; i < count; i++) 
        {
            System.out.println("Thread " + group[i].getName() + " found");
        }
    }
}

输出：

Starting one
Starting two
Thread one found
Thread two found
one finished executing
two finished executing

int enumerate(Thread[] group, boolean recurse)：将构成调用线程组的线程放入组数组中。如果 all 为true ，则线程的所有子组中的线程也被放入组中。

Syntax: public int enumerate(Thread[] list, boolean recurse).
Returns: the number of threads placed into the array.
Exception: SecurityException - if the current thread does 
not have permission to enumerate this thread group.

// Java code illustrating enumerate(Thread[] group, boolean recurse)
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
                System.out.println("Exception encounterted");
            }
        }
        System.out.println(Thread.currentThread().getName() +
              " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
  
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting one");
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting two");
  
        // returns the number of threads put into the array
        Thread[] group = new Thread[gfg.activeCount()];
        int count = gfg.enumerate(group, true);
        for (int i = 0; i < count; i++) 
        {
            System.out.println("Thread " + group[i].getName() + " found");
        }
    }
}

输出：

Starting one
Starting two
Thread one found
Thread two found
one finished executing
two finished executing

int enumerate(ThreadGroup[] group)：将调用线程组的子组放入组数组中。

Syntax: public int enumerate(ThreadGroup[] group).
Returns: the number of thread groups put into the array.
Exception: SecurityException - if the current thread does 
not have permission to enumerate this thread group.

// Java code illustrating enumerate(ThreadGroup[] group) method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
                System.out.println("Exception encounterted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
               " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
  
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting one");
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting two");
  
        // returns the number of threads put into the array
        ThreadGroup[] group = new ThreadGroup[gfg.activeCount()];
        int count = gfg.enumerate(group);
        for (int i = 0; i < count; i++) 
        {
            System.out.println("ThreadGroup " + group[i].getName() +
                " found");
        }
    }
}

输出：

Starting one
Starting two
ThreadGroup child thread found
two finished executing
one finished executing

int enumerate(ThreadGroup[] group, boolean all)：将调用线程组的子组放入组数组中。如果 all 为true ，则子组的所有子组（等等）也被放入组中。

Syntax: public int enumerate(ThreadGroup[] group, boolean all)
Returns: the number of thread groups put into the array.
Exception: SecurityException - if the current thread does 
not have permission to enumerate this thread group.

// Java code illustrating enumerate(ThreadGroup[] group, boolean all)
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
                System.out.println("Exception encounterted");
            }
        }
        System.out.println(Thread.currentThread().getName() +
               " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
  
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting one");
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting two");
  
        // returns the number of threads put into the array
        ThreadGroup[] group = new ThreadGroup[gfg.activeCount()];
        int count = gfg.enumerate(group, true);
        for (int i = 0; i < count; i++) 
        {
            System.out.println("ThreadGroup " + group[i].getName() + 
                " found");
        }
    }
}

输出：

Starting one
Starting two
ThreadGroup child thread found
two finished executing
one finished executing

int getMaxPriority()：返回组的最大优先级设置。

Syntax: final int getMaxPriority().
Returns: the maximum priority that a thread in this thread group can have.
Exception: NA.

// Java code illustrating getMaxPriority() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
                System.out.println("Exception encounterted");
            }
        }
        System.out.println(Thread.currentThread().getName() +
               " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        // checking the maximum priority of parent thread
        System.out.println("Maximum priority of ParentThreadGroup = "
                           + gfg.getMaxPriority());
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting one");
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting two");
    }
}

输出：

Maximum priority of ParentThreadGroup = 10
Starting one
Starting two
two finished executing
one finished executing

String getName()：此方法返回组的名称。

Syntax: final String getName().
Returns: the name of this thread group.
Exception: NA.

// Java code illustrating getName() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
                System.out.println("Exception encounterted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
             " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting " + t1.getName());
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting " + t2.getName());
    }
}

输出：

Starting one
Starting two
two finished executing
one finished executing

ThreadGroup getParent()：如果调用的 ThreadGroup 对象没有父级，则返回 null。否则，它返回调用对象的父对象。

Syntax: final ThreadGroup getParent().
Returns: the parent of this thread group. 
The top-level thread group is the only thread group 
whose parent is null.
Exception: SecurityException - if the current thread 
cannot modify this thread group.

// Java code illustrating getParent() method
import java.lang.*;
class NewThread extends Thread {
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) {
                System.out.println("Exception encounterted");
            }
        }
        System.out.println(Thread.currentThread().getName()
                                            + " finished executing");
    }
} public class ThreadGroupDemo {
public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting " + t1.getName());
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting " + t2.getName());
  
        // prints the parent ThreadGroup 
        // of both parent and child threads
        System.out.println("ParentThreadGroup for " + gfg.getName() +
                        " is " + gfg.getParent().getName());
        System.out.println("ParentThreadGroup for " + gfg_child.getName() 
                        + " is " + gfg_child.getParent().getName());
    }
}

输出：

Starting one
Starting two
ParentThreadGroup for Parent thread is main
ParentThreadGroup for child thread is Parent thread
one finished executing
two finished executing

void interrupt()：调用组内所有线程的interrupt()方法。

Syntax: public final void interrupt().
Returns: NA.
Exception: SecurityException - if the current thread is not 
allowed to access this thread group or any of the threads in the thread group.

// Java code illustrating interrupt() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
              System.out.println("Thread " + Thread.currentThread().getName()
                                   + " interrupted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
             " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting " + t1.getName());
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting " + t2.getName());
  
        // interrupting thread group
        gfg.interrupt();
    }
}

输出：

Starting one
Starting two
Thread two interrupted
Thread one interrupted
one finished executing
two finished executing

boolean isDaemon()：测试这个线程组是否是一个守护线程组。守护线程组在其最后一个线程停止或其最后一个线程组被销毁时自动销毁。

Syntax: public final boolean isDaemon().
Returns: true if the group is daemon group. Otherwise it returns false.
Exception: NA.

// Java code illustrating isDaemon() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
              System.out.println("Thread " + Thread.currentThread().getName()
                                   + " interrupted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
                " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting " + t1.getName());
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting " + t2.getName());
  
        if (gfg.isDaemon() == true)
            System.out.println("Group is Daemon group");
        else
            System.out.println("Group is not Daemon group");
    }
}

输出：

Starting one
Starting two
Group is not Daemon group
two finished executing
one finished executing

boolean isDestroyed()：这个方法测试这个线程组是否已经被销毁。

Syntax: public boolean isDestroyed().
Returns: true if this object is destroyed.
Exception: NA.

// Java code illustrating isDestroyed() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
              System.out.println("Thread " + Thread.currentThread().getName()
                                   + " interrupted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
                " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException, Exception
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting " + t1.getName());
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting " + t2.getName());
  
        if (gfg.isDestroyed() == true)
            System.out.println("Group is destroyed");
        else
            System.out.println("Group is not destroyed");
    }
}

输出：

Starting one
Starting two
Group is not destroyed
one finished executing
two finished executing

void list()：显示有关组的信息。

Syntax: public void list().
Returns: NA.
Exception: NA.

// Java code illustrating list() method.
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
              System.out.println("Thread " + Thread.currentThread().getName()
                                   + " interrupted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
              " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException, Exception
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting " + t1.getName());
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting " + t2.getName());
  
        // listing contents of parent ThreadGroup
        System.out.println("\nListing parentThreadGroup: " + gfg.getName() 
              + ":");
        // prints information about this thread group
        // to the standard output
        gfg.list();
    }
}

输出：

Starting one
Starting two

Listing parentThreadGroup: Parent thread:
java.lang.ThreadGroup[name=Parent thread, maxpri=10]
    Thread[one, 5, Parent thread]
    Thread[two, 5, Parent thread]
    java.lang.ThreadGroup[name=child thread, maxpri=10]
one finished executing
two finished executing

boolean parentOf(ThreadGroup group)：此方法测试此线程组是线程组参数还是其祖先线程组之一。

Syntax: final boolean parentOf(ThreadGroup group).
Returns: true if the invoking thread is the parent 
of group(or group itself). Otherwise, it returns false.
Exception: NA.

// Java code illustrating parentOf() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
              System.out.println("Thread " + Thread.currentThread().getName()
                                   + " interrupted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
                " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException, Exception
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting " + t1.getName());
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting " + t2.getName());
  
        // checking who is parent thread
        if (gfg.parentOf(gfg_child))
            System.out.println(gfg.getName() + " is parent of " +
               gfg_child.getName());
    }
}

输出：

Starting one
Starting two
Parent thread is parent of child thread
two finished executing
one finished executing

void setDaemon(boolean isDaemon)：这个方法改变这个线程组的守护进程状态。守护线程组在其最后一个线程停止或其最后一个线程组被销毁时自动销毁。

Syntax: final void setDaemon(boolean isDaemon).
Returns: If isDaemon is true, then the invoking group is 
flagged as a daemon group.
Exception: SecurityException - if the current 
thread cannot modify this thread group.

// Java code illustrating setDaemon() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
              System.out.println("Thread " + Thread.currentThread().getName()
                                   + " interrupted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
               " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException, Exception
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        // daemon status is set to true
        gfg.setDaemon(true);
  
        // daemon status is set to true
        gfg_child.setDaemon(true);
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting " + t1.getName());
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting " + t2.getName());
  
        if (gfg.isDaemon() && gfg_child.isDaemon())
            System.out.println("Parent Thread group and "
                               + "child thread group"
                               + " is daemon");
    }
}

输出：

Starting one
Starting two
Parent Thread group and child thread group is daemon
one finished executing
two finished executing

void setMaxPriority(int priority)：设置调用组的最大优先级为priority。

Syntax: final void setMaxPriority(int priority).
Returns: NA.
Exception: SecurityException - if the current thread 
cannot 
modify this thread group.

// Java code illustrating setMaxPriority() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
              System.out.println("Thread " + Thread.currentThread().getName()
                                   + " interrupted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
                 " [priority = " + 
           Thread.currentThread().getPriority() + "]
                finished executing.");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException, Exception
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
        gfg.setMaxPriority(Thread.MAX_PRIORITY - 2);
        gfg_child.setMaxPriority(Thread.NORM_PRIORITY);
  
        NewThread t1 = new NewThread("one", gfg);
        t1.setPriority(Thread.MAX_PRIORITY);
        System.out.println("Starting " + t1.getName());
        t1.start();
        NewThread t2 = new NewThread("two", gfg_child);
        t2.setPriority(Thread.MAX_PRIORITY);
        System.out.println("Starting " + t2.getName());
        t2.start();
    }
}

输出：

Starting one
Starting two
two [priority = 5] finished executing.
one [priority = 8] finished executing.

String toString()：此方法返回此线程组的字符串表示形式。

Syntax: public String toString().
Returns: String equivalent of the group.
Exception: SecurityException - if the current thread 
cannot modify this thread group.

// Java code illustrating toString() method
import java.lang.*;
class NewThread extends Thread 
{
    NewThread(String threadname, ThreadGroup tgob)
    {
        super(tgob, threadname);
        start();
    }
public void run()
    {
  
        for (int i = 0; i < 10; i++) 
        {
            try 
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ex) 
            {
              System.out.println("Thread " + Thread.currentThread().getName()
                                   + " interrupted");
            }
        }
        System.out.println(Thread.currentThread().getName() + 
              " finished executing");
    }
} 
public class ThreadGroupDemo 
{
    public static void main(String arg[]) throws InterruptedException,
        SecurityException, Exception
    {
        // creating the thread group
        ThreadGroup gfg = new ThreadGroup("Parent thread");
        ThreadGroup gfg_child = new ThreadGroup(gfg, "child thread");
  
        // daemon status is set to true
        gfg.setDaemon(true);
  
        // daemon status is set to true
        gfg_child.setDaemon(true);
        NewThread t1 = new NewThread("one", gfg);
        System.out.println("Starting " + t1.getName());
        NewThread t2 = new NewThread("two", gfg);
        System.out.println("Starting " + t2.getName());
  
        // string equivalent of the parent group
        System.out.println("String equivalent: " + gfg.toString());
    }
}

输出：

Starting one
Starting two
String equivalent: java.lang.ThreadGroup[name=Parent thread, maxpri=10]
one finished executing
two finished executing