Java Java.lang.ThreadGroup用法及代码示例

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

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

构造函数：

公共线程组(字符串名称)：构造一个新的线程组。这个新组的父级是当前正在运行的线程的线程组。
```
Throws: SecurityException - if the current thread cannot
 create a thread in the specified thread group.
```

公共线程组(线程组父级，字符串名称)：创建一个新的线程组。这个新组的父级是指定的线程组。

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

无效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

无效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枚举(线程组[]):组成调用线程组的线程被放入组数组中。

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 枚举(线程[]组，布尔递归)：组成调用线程组的线程被放入组数组中。如果一切都是真的，那么该线程的所有子组中的线程也被放入组中。

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枚举(ThreadGroup[]组):调用线程组的子组被放入组数组中。

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):调用线程组的子组被放入组数组中。如果一切都是真的，则子组的所有子组(以此类推)也被放入组中。

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

字符串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

无效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

布尔值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

布尔值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

无效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

布尔parentOf(线程组组)：此方法测试该线程组是否是线程组参数或其祖先线程组之一。

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

无效setDaemon(布尔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。

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.

字符串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

相关用法

注：本文由纯净天空筛选整理自佚名大神的英文原创作品 Java.lang.ThreadGroup class in Java。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。