enumerate在java_Java ThreadGroup enumerate()方法与示例

ThreadGroup类enumerate()方法

语法：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()方法在java.lang包中可用。

enumerate(Thread [] th1)方法用于复制线程组中的所有活动线程并放入给定数组Thread []中。

enumerate(Thread [] th2，boolean recurr1)方法用于复制线程组中的所有活动线程并放入给定数组Thread []中，但是如果给定的boolean变量设置为true，则引用该线程中的每个活动线程子组也包括在内。

enumerate(ThreadGroup [] tg1)方法用于复制线程组中的所有活动子组，并将其放入给定数组ThreadGroup []中。

enumerate(ThreadGroup [] tg2，boolean recurr2)方法用于复制线程组中的所有活动子组并放入给定数组ThreadGroup []中，但是如果给定的boolean变量设置为true，则引用该子组中的每个活动子组也包括在内。在复制该线程组中所有活动线程时，这些方法可能会引发异常。

SecurityException-当不允许当前线程枚举此ThreadGroup时，可能引发此异常。

这些方法是非静态方法，只能通过类对象访问，如果尝试使用类名访问这些方法，则会收到错误消息。

参数：在第一种情况下，Thread [] th1 –表示将一组复制线程放入其中的“线程”类型数组。

在第二种情况下，Thread [] th1，布尔值recurr1Thread [] th1 –与第一种情况下定义的相似。

boolean recurr1 –表示一个标志状态，表示包括线程是该线程组的子组的线程组。

在第三种情况下，ThreadGroup [] tg1 –表示“ ThreadGroup”类型的数组，将复制的线程组的集合放入其中。

在第四种情况下，ThreadGroup [] tg2，布尔值recurr2

ThreadGroup [] tg2 –与在第三种情况下定义的相似。

boolean recurr2 –表示标志状态，表示包括线程组。

返回值：

在第一种情况下，该方法的返回类型为int –它返回放入数组中的线程数的计数。

在第二种情况下，方法的返回类型为int –与第一种情况中定义的相似。

在第三种情况下，该方法的返回类型为int –它返回放置在数组中的线程组数的计数。

在第四种情况下，方法的返回类型为int –与在第三种情况下定义的相似。

示例//Java程序演示示例

//的enumerate()的方法ThreadGroup()类

public class Enumerate implements Runnable {

public static void main(String[] args) {

Enumerate en = new Enumerate();

en.enumerates();

}

public void enumerates() {

try {

//创建两个线程组，命名为base-

//并派生

ThreadGroup base = new ThreadGroup("Base ThreadGroup");

ThreadGroup derived = new ThreadGroup(base, "Derived ThreadGroup");

//创建两个线程

Thread th1 = new Thread(base, this);

Thread th2 = new Thread(derived, this);

//通过使用getName()方法是检索

//线程名称th1-

System.out.println(th1.getName() + " " + "begins.....");

//通过使用start()方法是开始执行

//线程th1-

th1.start();

//通过使用getName()方法是检索

//线程名称th2-

System.out.println(th2.getName() + " " + "begins.....");

//通过使用start()方法是开始执行

//线程th2-

th2.start();

Thread[] t1 = new Thread[base.activeCount()];

ThreadGroup[] tg1 = new ThreadGroup[base.activeGroupCount()];

//通过使用enumerate()方法是把

//复制数组中的线程

System.out.println();

int cnt1 = base.enumerate(t1);

for (int i = 0; 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 

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 

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 

System.out.print("enumerate(ThreadGroup[] tg1, boolean recurr) :");

System.out.println(tg1[l].getName() + " " + "exists");

}

//通过使用join()方法是等待当前

//线程直到另一个执行完全

//线程

th1.join();

th2.join();

} catch (InterruptedException ex) {

ex.printStackTrace();

}

}

//覆盖run()

public void run() {

for (int k = 0; k 

++k;

System.out.println(Thread.currentThread().getName() + " " + "ends.....");

}

}

输出结果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