008-多线程-基础-ThreadGroup线程组

    publicThread(ThreadGroup group, Runnable target) {
    init(group, target, "Thread-" + nextThreadNum(), 0);
    }
    publicThread(ThreadGroup group, String name) {
    init(group, null, name, 0);
    }
    publicThread(ThreadGroup group, Runnable target, String name) {
    init(group, target, name, 0);
    }
    publicThread(ThreadGroup group, Runnable target, String name,
                  longstackSize) {
    init(group, target, name, stackSize);
    }

    private voidinit(ThreadGroup g, Runnable target, String name,
                      longstackSize) {
    Thread parent =currentThread();
    SecurityManager security =System.getSecurityManager();
    if (g == null) {
         //安全检查
        if (security != null) {
        g =security.getThreadGroup();
        }
        //设置线程组
        if (g == null) {
        g =parent.getThreadGroup();
        }
    }
    //检查可达性
g.checkAccess();
     //是否有权限访问
    if (security != null) {
        if(isCCLOverridden(getClass())) {
            security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
        }
    }
     //往线程组添加线程但未启动
g.addUnstarted();
    this.group =g;
    this.daemon = parent.isDaemon();//是否守护线程
    this.priority = parent.getPriority();//优先级
    this.name =name.toCharArray();
    if (security == null ||isCCLOverridden(parent.getClass()))
        this.contextClassLoader =parent.getContextClassLoader();
    else
        this.contextClassLoader =parent.contextClassLoader;
    this.inheritedAccessControlContext =AccessController.getContext();
    this.target =target;
    setPriority(priority);
        if (parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        this.stackSize =stackSize;
        tid =nextThreadID();
        this.me = this;
    }

packagecom.lhx.common.thread;
importjava.util.Date;
importjava.util.Random;
importjava.util.concurrent.TimeUnit;
classResult {
    privateString name;
    publicString getName() {
        returnname;
    }
    public voidsetName(String name) {
        this.name =name;
    }
}
public class SearchTask implementsRunnable {
    publicSearchTask(Result result) {
        this.result =result;
    }
    privateResult result;
    @Override
    public voidrun() {
        String name =Thread.currentThread().getName();
        System.out.println("Thread Start " +name);
        try{
            doTask();
            result.setName(name);
        } catch(InterruptedException e) {
            System.out.printf("Thread %s: Interrupted
", name);
            return;
        }
        System.out.printf("%s :Thread end %s
" ,newDate(),name);
    }
    private void doTask() throwsInterruptedException {
        Random random = new Random((newDate()).getTime());
        int value = (int) (random.nextDouble() * 100);
        System.out.printf("%s :Thread %s: %d
",newDate(), Thread.currentThread().getName(),
                value);
        TimeUnit.SECONDS.sleep(value);
    }
    public static voidmain(String[] args) {
        System.out.println("main thread start:");
        //创建5个线程，并入group里面进行管理
        ThreadGroup threadGroup = new ThreadGroup("Searcher");
        Result result = newResult();
        SearchTask searchTask = newSearchTask(result);
        for (int i = 0; i < 5; i++) {
            Thread thred = newThread(threadGroup, searchTask);
            thred.start();
            try{
                TimeUnit.SECONDS.sleep(1);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
        //通过这种方法可以看group里面的所有信息
        System.out.printf("Number of Threads: %d
", threadGroup.activeCount());
        System.out.printf("Information about the Thread Group
");
        threadGroup.list();
        //这样可以复制group里面的thread信息
        Thread[] threads = newThread[threadGroup.activeCount()];
        threadGroup.enumerate(threads);
        for (int i = 0; i < threadGroup.activeCount(); i++) {
            System.out.printf("%s:Thread %s: %s
",newDate(), threads[i].getName(),
                    threads[i].getState());
        }
        waitFinish(threadGroup);
        //将group里面的所有线程都给interpet
threadGroup.interrupt();
        System.out.println("main thread end:");
    }
    private static voidwaitFinish(ThreadGroup threadGroup) {
        while (threadGroup.activeCount() > 0) {
            try{
                TimeUnit.SECONDS.sleep(1);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

packagecom.lhx.common.thread;
public classThreadGroupException {
    public static voidmain(String[] args) {
        ThreadGroup threadGroup1 =
                //这是匿名类写法
                new ThreadGroup("group1") {
                    //继承ThreadGroup并重新定义以下方法
                    //在线程成员抛出unchecked exception
                    //会执行此方法
                    public voiduncaughtException(Thread t, Throwable e) {
                        System.out.println(t.getName() + ": " +e.getMessage());
                    }
                };
        //这是匿名类写法
        Thread thread1 =
                //这个线程是threadGroup1的一员
                new Thread(threadGroup1, newRunnable() {
                    public voidrun() {
                        //抛出unchecked异常
                        throw new RuntimeException("测试异常");
                    }
                });
        thread1.start();
    }
}

    //此线程组及其子组中的所有活动线程复制到指定数组中。  
    public intenumerate(ThreadGroup list[]) {
        checkAccess();
        return enumerate(list, 0, true);
    }
    //此线程组及其子组中的所有活动线程复制到指定数组中。  
    public int enumerate(ThreadGroup list[], booleanrecurse) {
        checkAccess();
        return enumerate(list, 0, recurse);
    }
    //此线程组中的所有活动线程复制到指定数组中。如果 recurse 标志为 true，则还包括对此线程的子组中的所有活动线程的引用。如果数组太小而无法保持所有线程，则    
    //忽略额外的线程。  
    private int enumerate(ThreadGroup list[], int n, booleanrecurse) {
        int ngroupsSnapshot = 0;
        ThreadGroup[] groupsSnapshot = null;
        synchronized (this) {
            if(destroyed) {
                return 0;
            }
            int ng =ngroups;
            if (ng > list.length - n) {//防止list放不下线程数目  
                ng = list.length -n;
            }
            if (ng > 0) {
                System.arraycopy(groups, 0, list, n, ng);//复制线程组  
                n +=ng;
            }
            if (recurse) { //取得其子组  
                ngroupsSnapshot =ngroups;
                if (groups != null) {
                    groupsSnapshot =Arrays.copyOf(groups, ngroupsSnapshot);
                } else{
                    groupsSnapshot = null;
                }
            }
        }
        if (recurse) {//复制子组  
            for (int i = 0; i < ngroupsSnapshot; i++) {
                n = groupsSnapshot[i].enumerate(list, n, true);
            }
        }
        returnn;
    }