Java線程組

類似于在計(jì)算機(jī)中使用文件夾管理文件,也可以使用線程組來管理線程，在線程組中定義一組相似(相關(guān))的線程，在線程組中也可以定義子線程組。

Thread類有幾個(gè)構(gòu)造方法允許在創(chuàng)建線程時(shí)指定線程組,如果在創(chuàng)建線程時(shí)沒有指定線程組則該線程就屬于父線程所在的線程組，JVM在創(chuàng)建main線程時(shí)會(huì)為它指定一個(gè)線程組,因此每個(gè)Java線程都有一個(gè)線程組與之關(guān)聯(lián), 可以調(diào)用線程的getThreadGroup()方法返回線程組。

線程組開始是出于安全的考慮設(shè)計(jì)用來區(qū)分不同的Applet，然而ThreadGroup并未實(shí)現(xiàn)這一目標(biāo),在新開發(fā)的系統(tǒng)中，已經(jīng)不常用線程組，現(xiàn)在一般會(huì)將一組相關(guān)的線程存入一個(gè)數(shù)組或一個(gè)集合中，如果僅僅是用來區(qū)分線程時(shí),可以使用線程名稱來區(qū)分，多數(shù)情況下,可以忽略線程組。

Java創(chuàng)建線程組

package com.wkcto.threadgroup;

/**
 * 演示創(chuàng)建線程組
 */
public class Test01 {
    public static void main(String[] args) {
        // 1) 返回當(dāng)前main線程的線程組
        ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();
        System.out.println(mainGroup);

        //2) 定義線程組,如果不指定所屬線程組,則自動(dòng)歸屬當(dāng)前線程所屬的線程組中
        ThreadGroup group1 = new ThreadGroup("group1");
        System.out.println(group1);

        //3)定義線程組, 同時(shí)指定父線程組
        ThreadGroup group2 = new ThreadGroup(mainGroup, "group2");
        //現(xiàn)在group1與group2都是maingroup線程組中的子線程組, 調(diào)用線程組的getParent()方法返回父線程組
        System.out.println( group1.getParent() == mainGroup);       //true
        System.out.println( group2.getParent() == mainGroup);

        //4) 在創(chuàng)建線程時(shí)指定所屬線程組
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread());
            }
        };
        //在創(chuàng)建線程時(shí),如果沒有指定線程組,則默認(rèn)線程歸屬到父線程的線程組中
        //在main線程中創(chuàng)建了t1線程,稱main線程為父線程,t1線程為子線程, t1沒有指定線程組則t1線程就歸屬到父線程main線程的線程組中
        Thread t1 = new Thread(r, "t1");
        System.out.println( t1 );   //Thread[t1,5,main], t1的線程組是main線程組
        //創(chuàng)建線程時(shí),可以指定線程所屬線程組
        Thread t2 = new Thread(group1, r, "t2");
        Thread t3 = new Thread(group2, r, "t3");
        System.out.println(t2);
        System.out.println(t3);
    }
}

Java線程組的基本操作

activeCount() 返回當(dāng)前線程組及子線程組中活動(dòng)線程的數(shù)量(近似值)。

activeGroupCount() 返回當(dāng)前線程組及子線程組中活動(dòng)線程組的數(shù)量(近似值)。

int enumerate(Thread[] list) 將當(dāng)前線程組中的活動(dòng)線程復(fù)制到參數(shù)數(shù)組中。

enumerate(ThreadGroup[] list) 將當(dāng)前線程組中的活動(dòng)線程組復(fù)制到參數(shù)數(shù)組中。

getMaxPriority() 返回線程組的最大優(yōu)先級(jí),默認(rèn)是10。

getName() 返回線程組的名稱。

getParent() 返回父線程組。

interrupt() 中斷線程組中所有的線程。

isDaemon() 判斷當(dāng)前線程組是否為守護(hù)線程組。

list() 將當(dāng)前線程組中的活動(dòng)線程打印出來。

parentOf(ThreadGroup g) 判斷當(dāng)前線程組是否為參數(shù)線程組的父線程組。

setDaemon(boolean daemon) 設(shè)置線程組為守護(hù)線程組。

package com.wkcto.threadgroup;

/**
 * 演示線程組的基本操作
 */
public class Test02 {
    public static void main(String[] args) {
        ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();    //返回當(dāng)前線程組
        //再定義線程組
        ThreadGroup group = new ThreadGroup("group");  //默認(rèn)group的父線程組是main線程組

        Runnable r = new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("-----------當(dāng)前線程: " + Thread.currentThread());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread t1 = new Thread(r, "t1");        //默認(rèn)在main線程組中創(chuàng)建線程
        Thread t2 = new Thread(group, r, "t2");     //在指定的group線程組中創(chuàng)建線程
        t1.start();
        t2.start();

        //打印線程組的相關(guān)屬性
        System.out.println("main 線程組中活動(dòng)線程數(shù)量: " + mainGroup.activeCount());  //4, main線程組中活動(dòng)線程: main, t1, t2, 垃圾回收器
        System.out.println("group 子線程組中活動(dòng)線程數(shù)量: " + group.activeCount());    //1,  t2
        System.out.println("main線程組中子線程組數(shù)量: " + mainGroup.activeGroupCount());  //1,  group
        System.out.println("group子線程組中子線程組數(shù)量: " + group.activeGroupCount());    //0
        System.out.println("main線程組的父線程組: " + mainGroup.getParent());   //main線程組的父線程組是system
        System.out.println("group線程組的父線程組: " + group.getParent());  //main
        System.out.println( mainGroup.parentOf(mainGroup));  //true, 線程組也是它自己的父線程組
        System.out.println( mainGroup.parentOf(group));     //true
        mainGroup.list();   //把main線程組中所有的線程打印輸出
    }
}

復(fù)制線程組中的線程及子線程組

enumerate(Thread[] list) 把當(dāng)前線程組和子線程組中所有的線程復(fù)制到參數(shù)數(shù)組中。

enumerate(Thread[] list, boolean recursive) , 如果第二個(gè)參數(shù)設(shè)置為false,則只復(fù)制當(dāng)前線程組中所有的線程,不復(fù)制子線程組中的線程。

enumerate(ThreadGroup[] list) 把當(dāng)前線程組和子線程組中所有的線程組復(fù)制到參數(shù)數(shù)組中。

enumerate(ThreadGroup[] list, boolean recurse) 第二個(gè)參數(shù)設(shè)置false,則只復(fù)制當(dāng)前線程組的子線程組。

package com.wkcto.threadgroup;

/**
 * 演示復(fù)制線程組中的內(nèi)容
 */
public class Test03 {
    public static void main(String[] args) {
        ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();    //返回main線程的main線程組

        //main線程組中定義了兩個(gè)子線程組
        ThreadGroup group1 = new ThreadGroup("group1");     //默認(rèn)group1的父線程組就是當(dāng)前線程組main
        ThreadGroup group2 = new ThreadGroup(mainGroup, "group2");

        Runnable r = new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("----當(dāng)前線程: " + Thread.currentThread());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        //創(chuàng)建并啟動(dòng)三個(gè)線程
        Thread t1 = new Thread(r, "t1");    //默認(rèn)在main線程組中創(chuàng)建線程
        Thread t2 = new Thread(group1, r, "t2");    //在group1線程組中創(chuàng)建線程
        Thread t3 = new Thread(group2, r, "t3");    //在group2線程組中創(chuàng)建線程
        t1.start();
        t2.start();
        t3.start();

        //1) 把main線程組中的線程復(fù)制到數(shù)組中
        //先定義存儲(chǔ)線程的數(shù)組,數(shù)組的長(zhǎng)度為main線程組中活動(dòng)線程的數(shù)量
        Thread[] threadList = new Thread[mainGroup.activeCount()];
 /*       //把main線程組包括子線程組中的所有的線程復(fù)制到數(shù)組中
        mainGroup.enumerate(threadList);
        //遍歷threadList數(shù)組
        for (Thread thread : threadList) {
            System.out.println(thread);
        }
        System.out.println("----------------------------");*/

        //只把main線程組中的線程復(fù)制到數(shù)組中,不包含子線程組的線程
        mainGroup.enumerate(threadList, false);
        //遍歷threadList數(shù)組
        for (Thread thread : threadList) {
            System.out.println(thread);
        }
        System.out.println("----------------------------");

        //2) 把main線程組中的子線程組復(fù)制到數(shù)組中
        //定義數(shù)組存儲(chǔ)線程組
        ThreadGroup [] threadGroups = new ThreadGroup[mainGroup.activeGroupCount()];
        //把main線程組中的子線程組復(fù)制到數(shù)組中
        mainGroup.enumerate(threadGroups);
        System.out.println("============================");
        for (ThreadGroup threadGroup : threadGroups) {
            System.out.println(threadGroup);
        }
    }
}

線程組的批量中斷

線程組的interrupt() 可以給該線程組中所有的活動(dòng)線程添加中斷標(biāo)志。

package com.wkcto.threadgroup;

/**
 * 線程組的批量中斷
 */
public class Test04 {
    public static void main(String[] args) throws InterruptedException {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("當(dāng)前線程--" + Thread.currentThread() + "--開始循環(huán)");
                //當(dāng)線程沒有被中斷就一直循環(huán)
                while ( !Thread.currentThread().isInterrupted()){
                    System.out.println(Thread.currentThread().getName() + "------------------");
                  /*  try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        //如果中斷睡眠中的線程,產(chǎn)生中斷異常, 同時(shí)會(huì)清除中斷標(biāo)志
                        e.printStackTrace();
                    }*/
                }
                System.out.println(Thread.currentThread().getName() + "循環(huán)結(jié)束");
            }
        };

        //創(chuàng)建線程組
        ThreadGroup group = new ThreadGroup("group");

        //在group線程組中創(chuàng)建5個(gè)線程
        for (int i = 0; i < 5; i++) {
            new Thread(group,r).start();
        }

        //main線程睡眠2秒
        Thread.sleep(50);
        //中斷線程組, 會(huì)中斷線程組中所有的線程
        group.interrupt();
    }
}

設(shè)置守護(hù)線程組

守護(hù)線程是為其他線程提供服務(wù)的,當(dāng)JVM中只有守護(hù)線程時(shí),守護(hù)線程會(huì)自動(dòng)銷毀,JVM會(huì)退出。

調(diào)用線程組的setDaemon(true)可以把線程組設(shè)置為守護(hù)線程組,當(dāng)守護(hù)線程組中沒有任何活動(dòng)線程時(shí),守護(hù)線程組會(huì)自動(dòng)銷毀。

注意線程組的守護(hù)屬性,不影響線程組中線程的守護(hù)屬性,或者說守護(hù)線程組中的線程可以是非守護(hù)線程。

package com.wkcto.threadgroup;

/**
 * 演示設(shè)置守護(hù)線程組
 */
public class Test05 {
    public static void main(String[] args) throws InterruptedException {
        //先定義線程組
        ThreadGroup group = new ThreadGroup("group");

        //設(shè)置線程組為守護(hù)線程組
        group.setDaemon(true);

        //向組中添加3個(gè)線程
        for (int i = 0; i < 3; i++) {
            new Thread(group, new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 20; j++) {
                        System.out.println(Thread.currentThread().getName() + " -- " + j);
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }

        //main線程睡眠5秒
        Thread.sleep(5000);
        System.out.println("main...end....");
    }
}