Clase Java.lang.ThreadGroup en Java

ThreadGroup crea un grupo de hilos. Ofrece una manera conveniente de administrar grupos de subprocesos como una unidad. Esto es particularmente valioso en situaciones en las que desea suspender y reanudar varios hilos relacionados.

  • El grupo de subprocesos forma un árbol en el que cada grupo de subprocesos, excepto el grupo de subprocesos inicial, tiene un padre.
  • Un subproceso puede acceder a la información sobre su propio grupo de subprocesos, pero no acceder a la información sobre el grupo de subprocesos principal de su grupo de subprocesos o cualquier otro grupo de subprocesos.

Constructores:

  1. public ThreadGroup(String name): Construye un nuevo grupo de subprocesos. El padre de este nuevo grupo es el grupo de subprocesos del subproceso que se está ejecutando actualmente.
    Throws: SecurityException - if the current thread cannot
     create a thread in the specified thread group.
    
  2. public ThreadGroup (ThreadGroup parent, String name): crea un nuevo grupo de subprocesos. El padre de este nuevo grupo es el grupo de subprocesos especificado.
    Throws: 
    NullPointerException - if the thread group argument is null.
    SecurityException - if the current thread cannot create a thread in the 
    specified thread group.
    

Métodos

  1. int activeCount(): este método devuelve el número de subprocesos en el grupo más cualquier grupo para el que este subproceso sea padre.
    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());
        }
    }

    Producción:

    Starting one
    Starting two
    number of active thread: 2
    
  2. int activeGroupCount(): este método devuelve una estimación del número de grupos activos en este grupo de subprocesos.
    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());
        }
    }

    Producción:

    Starting one
    Starting two
    number of active thread group: 2
    one finished executing
    two finished executing
    
  3. void checkAccess(): hace que el administrador de seguridad verifique que el subproceso que invoca puede acceder y/o cambiar el grupo en el que se llama 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");
        }
    }

    Producción:

    Starting one
    Starting two
    Parent thread has access
    child thread has access
    one finished executing 
    two finished executing
    
  4. void destroy(): Destruye el grupo de subprocesos y cualquier grupo secundario en el que se llame.
    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");
        }
    }

    Producción:

    Starting one
    Starting two
    child thread destroyed
    Parent thread destroyed
    
  5. int enumerar (Grupo de subprocesos []): el subproceso que comprende el grupo de subprocesos que invoca se coloca en la array del grupo.
    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");
            }
        }
    }

    Producción:

    Starting one
    Starting two
    Thread one found
    Thread two found
    one finished executing
    two finished executing
    
  6. int enumerate(Thread[] group, boolean recurse): Los subprocesos que componen el grupo de subprocesos que invocan se colocan en la array de grupos. Si todo es verdadero , los subprocesos de todos los subgrupos del subproceso también se agrupan.
    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");
            }
        }
    }

    Producción:

    Starting one
    Starting two
    Thread one found
    Thread two found
    one finished executing
    two finished executing
    
  7. int enumerate(ThreadGroup[] group): Los subgrupos del grupo de subprocesos evocadores se colocan en la array de grupos.
    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");
            }
        }
    }

    Producción:

    Starting one
    Starting two
    ThreadGroup child thread found
    two finished executing
    one finished executing
    
  8. int enumerate(ThreadGroup[] group, boolean all): los subgrupos del grupo de subprocesos que invocan se colocan en la array de grupos. Si todo es verdadero , todos los subgrupos de los subgrupos (y así sucesivamente) también se agrupan.
    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");
            }
        }
    }

    Producción:

    Starting one
    Starting two
    ThreadGroup child thread found
    two finished executing
    one finished executing
    
  9. int getMaxPriority(): Devuelve la configuración de prioridad máxima para el grupo.
    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");
        }
    }

    Producción:

    Maximum priority of ParentThreadGroup = 10
    Starting one
    Starting two
    two finished executing
    one finished executing
    
  10. String getName(): este método devuelve el nombre del grupo.
    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());
        }
    }

    Producción:

    Starting one
    Starting two
    two finished executing
    one finished executing
    
  11. ThreadGroup getParent(): devuelve un valor nulo si el objeto ThreadGroup que invoca no tiene padre. De lo contrario, devuelve el padre del objeto que invoca.
    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());
        }
    }

    Producción:

    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(): invoca los métodos interrupt() de todos los subprocesos del grupo.
    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();
        }
    }

    Producción:

    Starting one
    Starting two
    Thread two interrupted
    Thread one interrupted
    one finished executing
    two finished executing
    
  13. boolean isDaemon(): Comprueba si este grupo de subprocesos es un grupo de subprocesos daemon. Un grupo de subprocesos daemon se destruye automáticamente cuando se detiene su último subproceso o se destruye su último grupo de subprocesos.
    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");
        }
    }

    Producción:

    Starting one
    Starting two
    Group is not Daemon group
    two finished executing
    one finished executing
    
  14. boolean isDestroyed(): Este método prueba si este grupo de subprocesos ha sido destruido.
    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");
        }
    }

    Producción:

    Starting one
    Starting two
    Group is not destroyed
    one finished executing
    two finished executing
    
  15. void list(): Muestra información sobre el grupo.
    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();
        }
    }

    Producción:

    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): este método prueba si este grupo de subprocesos es el argumento del grupo de subprocesos o uno de sus grupos de subprocesos antepasados.
    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());
        }
    }

    Producción:

    Starting one
    Starting two
    Parent thread is parent of child thread
    two finished executing
    one finished executing
    
  17. void setDaemon(boolean isDaemon): este método cambia el estado del demonio de este grupo de subprocesos. Un grupo de subprocesos daemon se destruye automáticamente cuando se detiene su último subproceso o se destruye su último grupo de subprocesos.
    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");
        }
    }

    Producción:

    Starting one
    Starting two
    Parent Thread group and child thread group is daemon
    one finished executing
    two finished executing
    
  18. void setMaxPriority (prioridad int): establece la prioridad máxima del grupo invocador en prioridad.
    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();
        }
    }

    Producción:

    Starting one
    Starting two
    two [priority = 5] finished executing.
    one [priority = 8] finished executing.
    
  19. String toString(): este método devuelve una representación de string de este grupo de subprocesos.
    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());
        }
    }

    Producción:

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

Este artículo es una contribución de Abhishek Verma . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *