📜  Java Java类

📅  最后修改于: 2022-05-13 01:55:11.115000             🧑  作者: Mango

Java Java类

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

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

构造函数:

  1. public ThreadGroup(String name):构造一个新的线程组。这个新组的父组是当前运行线程的线程组。
    Throws: SecurityException - if the current thread cannot
     create a thread in the specified thread group.
    
  2. 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.
    

方法

  1. 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
    
  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
    
  3. 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
    
  4. 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
    
  5. 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
    
  6. 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
    
  7. 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
    
  8. 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
    
  9. 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
    
  10. 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
    
  11. 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
    
  12. 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
    
  13. 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
    
  14. 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
    
  15. 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
    
  16. 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
    
  17. 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
    
  18. 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.
    
  19. 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