zoukankan      html  css  js  c++  java

  • 2，ThreadGroup 概念以及用法

    当一个任务需要多个子线程去处理业务，这时候不希望这些子线程杂乱无章， 就需要把这些线程统一管理起来，这时候线程组就产生了。

    ThreadGroup  常用方法讲解

    1. activeCount()   返回此线程组中活动线程的估计数。
    2. activeGroupCount() 返回此线程组中活动线程组的估计数。
    3. enumerate(Thread[] list)   把此线程组及其子组中的所有活动线程复制到指定数组中。
    4. enumerate(Thread[] list, boolean recurse)  把此线程组中的所有活动线程复制到指定数组中。
    5. interrupt() 中断此线程组中的所有线程。
     1 package com.zyguo.thread;
 2 
 3 public class SleepRunnable implements Runnable{
 4     private int sleepTime;
 5     public SleepRunnable( int sleepTime ){
 6         this.sleepTime = sleepTime;
 7     }
 8     @Override
 9     public void run() {
10         try {
11             System.out.println( Thread.currentThread() + " begin sleep " + this.sleepTime );
12             Thread.sleep( sleepTime );
13             System.out.println( Thread.currentThread() + " end sleep " + this.sleepTime );
14         } catch (InterruptedException e) {
15             // TODO Auto-generated catch block
16             e.printStackTrace();
17         }
18     }
19 }
     1 package com.zyguo.thread;
 2 
 3 import java.util.ArrayList;
 4 
 5 
 6 public class ThreadGroupMain {
 7     public static void main(String[] args) {
 8         int threadNum = 10;
 9         final ThreadGroup tgroup = new ThreadGroup("test-threadgroup");
10         ArrayList<Thread> tList = new ArrayList<>();
11         //定义10个线程
12         for( int i = 0; i < threadNum; i++ ){
13             Thread t = new Thread( tgroup, new SleepRunnable( 5000 + i*1000) ,"test-thread-" + i);
14             tList.add( t );
15         }
16 
17         System.out.println("before start, activeCount=" + tgroup.activeCount() );
18 
19         //检验 enumerate 方法
20         Thread[] threads = new Thread[threadNum];
21         //获取所有的子线程
22         int num = tgroup.enumerate( threads );
23         System.out.println( "befor start thread, enumerate num=" + num );
24         for (Thread thread : tList) {
25             thread.start();
26             System.out.println("start thread = " + thread );
27         }
28         num = tgroup.enumerate( threads );
29         System.out.println( "all thread start, enumerate num=" + num );
30         
31         //监控线程的活动的子线程数
32         Thread t = new Thread( new Runnable() {
33             @Override
34             public void run() {
35                 int activeCount = tgroup.activeCount();
36                 while ( activeCount > 0 ) {
37                     System.out.println("activeCount=" + activeCount );
38                     try {
39                         Thread.sleep(1000);
40                     } catch (InterruptedException e) {
41                         e.printStackTrace();
42                     }
43                     activeCount = tgroup.activeCount();
44                 }
45                 System.out.println("all thread is stop, activeCount=" + activeCount );        
46             }
47         });
48         
49         t.start();
50         
51         
52         
53         
54         
55     }
56 }

    结果如下

    before start, activeCount=0
befor start thread, enumerate num=0
start thread = Thread[test-thread-0,5,test-threadgroup]
Thread[test-thread-0,5,test-threadgroup] begin sleep 5000
Thread[test-thread-1,5,test-threadgroup] begin sleep 6000
start thread = Thread[test-thread-1,5,test-threadgroup]
start thread = Thread[test-thread-2,5,test-threadgroup]
start thread = Thread[test-thread-3,5,test-threadgroup]
Thread[test-thread-3,5,test-threadgroup] begin sleep 8000
Thread[test-thread-2,5,test-threadgroup] begin sleep 7000
start thread = Thread[test-thread-4,5,test-threadgroup]
Thread[test-thread-4,5,test-threadgroup] begin sleep 9000
start thread = Thread[test-thread-5,5,test-threadgroup]
Thread[test-thread-5,5,test-threadgroup] begin sleep 10000
start thread = Thread[test-thread-6,5,test-threadgroup]
Thread[test-thread-6,5,test-threadgroup] begin sleep 11000
start thread = Thread[test-thread-7,5,test-threadgroup]
Thread[test-thread-7,5,test-threadgroup] begin sleep 12000
start thread = Thread[test-thread-8,5,test-threadgroup]
Thread[test-thread-8,5,test-threadgroup] begin sleep 13000
start thread = Thread[test-thread-9,5,test-threadgroup]
Thread[test-thread-9,5,test-threadgroup] begin sleep 14000
all thread start, enumerate num=10
activeCount=10
activeCount=10
activeCount=10
activeCount=10
activeCount=10
Thread[test-thread-0,5,test-threadgroup] end sleep 5000
activeCount=9
Thread[test-thread-1,5,test-threadgroup] end sleep 6000
activeCount=8
Thread[test-thread-2,5,test-threadgroup] end sleep 7000
activeCount=7
Thread[test-thread-3,5,test-threadgroup] end sleep 8000
activeCount=6
Thread[test-thread-4,5,test-threadgroup] end sleep 9000
activeCount=5
Thread[test-thread-5,5,test-threadgroup] end sleep 10000
activeCount=4
Thread[test-thread-6,5,test-threadgroup] end sleep 11000
activeCount=3
Thread[test-thread-7,5,test-threadgroup] end sleep 12000
activeCount=2
Thread[test-thread-8,5,test-threadgroup] end sleep 13000
activeCount=1
Thread[test-thread-9,5,test-threadgroup] end sleep 14000
all thread is stop, activeCount=0

    附上 ThreadGroup 所有的api 

    方法摘要
     int activeCount() 
              返回此线程组中活动线程的估计数。
     int activeGroupCount() 
              返回此线程组中活动线程组的估计数。
     boolean allowThreadSuspension(boolean b) 
              已过时。 此调用的定义取决于 suspend()，它被废弃了。更进一步地说，此调用的行为从不被指定。
     void checkAccess() 
              确定当前运行的线程是否有权修改此线程组。
     void destroy() 
              销毁此线程组及其所有子组。
     int enumerate(Thread[] list) 
              把此线程组及其子组中的所有活动线程复制到指定数组中。
     int enumerate(Thread[] list, boolean recurse) 
              把此线程组中的所有活动线程复制到指定数组中。
     int enumerate(ThreadGroup[] list) 
              把对此线程组中的所有活动子组的引用复制到指定数组中。
     int enumerate(ThreadGroup[] list, boolean recurse) 
              把对此线程组中的所有活动子组的引用复制到指定数组中。
     int getMaxPriority() 
              返回此线程组的最高优先级。
     String getName() 
              返回此线程组的名称。
     ThreadGroup getParent() 
              返回此线程组的父线程组。
     void interrupt() 
              中断此线程组中的所有线程。
     boolean isDaemon() 
              测试此线程组是否为一个后台程序线程组。
     boolean isDestroyed() 
              测试此线程组是否已经被销毁。
     void list() 
              将有关此线程组的信息打印到标准输出。
     boolean parentOf(ThreadGroup g) 
              测试此线程组是否为线程组参数或其祖先线程组之一。
     void resume() 
              已过时。 此方法只用于联合 Thread.suspend 和 ThreadGroup.suspend 时，因为它们所固有的容易导致死锁的特性，所以两者都已废弃。有关详细信息，请参阅 Thread.suspend()。
     void setDaemon(boolean daemon) 
              更改此线程组的后台程序状态。
     void setMaxPriority(int pri) 
              设置线程组的最高优先级。
     void stop() 
              已过时。 此方法具有固有的不安全性。有关详细信息，请参阅 Thread.stop()。
     void suspend() 
              已过时。 此方法容易导致死锁。有关详细信息，请参阅 Thread.suspend()。
     String toString() 
              返回此线程组的字符串表示形式。
     void uncaughtException(Thread t, Throwable e) 
              当此线程组中的线程因为一个未捕获的异常而停止，并且线程没有安装特定 Thread.UncaughtExceptionHandler 时，由 Java Virtual Machine 调用此方法。

     
  • 相关阅读:
    SDSF output to PS
    3亿人出走后的中国农村，路在何方？
    oracle function
    C8051特点
    c8051单片机注意事项：
    一个因xdata声明引起的隐含错误
    宏 函数 内联函数inline
    字符串与液晶显示的一个问题
    XON/OFF
    excel之实验数据处理线性拟合
  • 原文地址：https://www.cnblogs.com/zyguo/p/4349954.html
Copyright © 2011-2022 走看看