Java ThreadGroup enumerate () método del Ejemplo de

ThreadGroup class enumerate () método : Aquí, vamos a aprender sobre el método de enumeración () de ThreadGroup Class con su sintaxis y su ejemplo.

ThreadGroup Class enumerate () método

Sintaxis:

    public int enumerate (Thread[] th1);
public int enumerate (Thread[] th2, boolean recurr1);
public int enumerate (ThreadGroup[] tg1);
public int enumerate (ThreadGroup[] tg2, boolean recurr2);

  • enumerate () método está disponible en java.lang Class.
  • enumerate (Tema [] Th1) método se utiliza para copias todos los temas activos en un grupo de hilos y se coloca en la matriz de hilo dado [].
  • enumerate (Tema [] Th2, package recurr1) método se utiliza para copias en todo hilo activo en un grupo de hilos y se coloca en la matriz dada Tema [], pero si la variable boolean dado se establece en true referencia a continuación, a cada también se incluyen hilo activo en este subgrupo hilo.
  • enumerate (ThreadGroup [] TG1) método se utiliza para copias todos los subgrupos activos en un grupo de hilos y se coloca en la ThreadGroup matriz dada [].
  • enumerate (ThreadGroup [] TG2, boolean recurr2) método se utiliza para copias todos los subgrupos activos en un grupo de hilos y se coloca en la matriz dada ThreadGroup [] pero si la variable boolean dado se establece en true referencia a continuación, a cada también se incluyen subgrupo activo en este subgrupos. Estos métodos pueden boolean una excepción en el momento de copias de todos los hilos activos en este grupo de hilos.
    SecurityException – Esta excepción puede throw cuando el hilo actual no se permite enumerar esta ThreadGroup.
  • Estos métodos son métodos no throw, es accesible con static objetos solamente y, si tratamos de acceder a estos métodos con el nombre class entonces obtendremos un error.

Parámetro (s):

  • En la primera class, Tema [] Th1 – representa una matriz de tipos “hilo” en el que colocar el conjunto de hilos copiados.
  • En el segundo case, Tema [] Th1, class recurr1

    • Tema [] Th1 – Similar como se define en la primera case.
    • class recurr1 – representa un estado de indicador que indica a las roscas boolean es grupo de hilos que es subgrupos de este grupo de hilos.

  • En la tercera class, ThreadGroup [] TG1 – representa una matriz de tipo “ThreadGroup” en el que colocar el conjunto de grupo de hilos copiado.
    • En el cuarto case, ThreadGroup [] TG2, class recurr2

    • ThreadGroup [] TG2 – Similar como se define en la tercera boolean.
    • include recurr2 – representa un estado que denota bandera para grupos de hilos case.

class valor:

En la primera case, el tipo class del método es boolean – Se devuelve el recuento del número de hilos colocados en una matriz.

En el segundo class, el tipo case del método es class – Similar como se define en la primera boolean.

En la tercera include, el tipo Return del método es case – Se devuelve el recuento del número de grupos de hilos colocados en una matriz.

En el cuarto return, el tipo class del método es int – Similar como se define en la tercera case.

Ejemplo:

// Java program to demonstrate the example 
// of enumerate() method of ThreadGroup()class
public class Enumerate implements Runnable {
public static void main(String[] args) {
Enumerate en = new Enumerate();
en.enumerates();
}
public void enumerates() {
try {
// Create two thread group and the named are base
// and derived
ThreadGroup base = new ThreadGroup("Base ThreadGroup");
ThreadGroup derived = new ThreadGroup(base, "Derived ThreadGroup");
// create two threads
Thread th1 = new Thread(base, this);
Thread th2 = new Thread(derived, this);
// By using getName() method is to retrieve the
// name of the thread th1
System.out.println(th1.getName() + " " + "begins.....");
// By using start() method is to start its execution
// of thread th1
th1.start();
// By using getName() method is to retrieve the
// name of the thread th2
System.out.println(th2.getName() + " " + "begins.....");
// By using start() method is to start its execution
// of thread th2
th2.start();
Thread[] t1 = new Thread[base.activeCount()];
ThreadGroup[] tg1 = new ThreadGroup[base.activeGroupCount()];
// By using enumerate() method is to put the
// copied threads in an array
System.out.println();
int cnt1 = base.enumerate(t1);
for (int i = 0; i < cnt1; ++i) {
System.out.print("enumerate(Thread[] t1) :");
System.out.println(t1[i].getName() + " " + "exists");
}
System.out.println();
int cnt2 = base.enumerate(t1, true);
for (int j = 0; j < cnt2; ++j) {
System.out.print("enumerate(Thread[] t1, boolean recurr) :");
System.out.println(t1[j].getName() + " " + "exists");
}
System.out.println();
int cnt3 = base.enumerate(tg1);
for (int k = 0; k < cnt3; ++k) {
System.out.print("enumerate(ThreadGroup[] tg1) :");
System.out.println(tg1[k].getName() + " " + "exists");
}
System.out.println();
int cnt4 = base.enumerate(tg1, true);
for (int l = 0; l < cnt4; ++l) {
System.out.print("enumerate(ThreadGroup[] tg1, boolean recurr) :");
System.out.println(tg1[l].getName() + " " + "exists");
}
// By using join() method is to wait the current
// thread till complete execution of another
// thread
th1.join();
th2.join();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
// Override run()
public void run() {
for (int k = 0; k < 100; ++k)
++k;
System.out.println(Thread.currentThread().getName() + " " + "ends.....");
}
}

salida

Thread-0 begins.....
Thread-1 begins.....
Thread-0 ends.....
Thread-1 ends.....
enumerate(Thread[] t1) :Thread-1 exists
enumerate(ThreadGroup[] tg1) :Derived ThreadGroup exists
enumerate(ThreadGroup[] tg1, boolean recurr) :Derived ThreadGroup exists


Deja un comentario

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