多线程--线程组

雨点打透心脏的1/2处 2024-02-19 14:42 20阅读 0赞

线程可以归属到某个线程组中，线程组可以有线程对象，也可以有线程组，组中还可以有线程。线程组的结构形式类似与树形结构。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70][]

线程组：可以批量的管理线程或者线程组的对象，可以有效的对线程或线程组对象进行组织管理。

单级关联：父中有子。

多级关联：父中有子，子中有子，子子无穷尽。

单级关联：

public static void main(String[] args) {
    
            Thread a = new Thread(() -> {
                System.out.println("ThreadName = " + Thread.currentThread().getName());
            }, "A");
           Thread b = new Thread(() -> {
                System.out.println("ThreadName = " + Thread.currentThread().getName());
            }, "A");
            ThreadGroup group = new ThreadGroup("线程组");
            Thread athread = new Thread(group, a);
            Thread bthread = new Thread(group, b);
            athread.start();
            bthread.start();
            System.out.println("活动的线程数为：" + group.activeCount());
            System.out.println("线程组的名称为：" + group.getName());
        }

多级关联：

public static void main(String[] args) {
    
            Thread newThread = new Thread(new ThreadGroup(Thread.currentThread().getThreadGroup(), "A"), new Runnable() {
                public void run() {
                    try {
                        System.out.println("run!");
                        Thread.sleep(10000);//运行状态才可以受组管理
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            newThread.setName("z");
            newThread.start();//线程启动然后才归到组A
    
            ThreadGroup[] listGroup = new ThreadGroup[Thread.currentThread().getThreadGroup().activeGroupCount()];
            Thread.currentThread().getThreadGroup().enumerate(listGroup);
            System.out.println("main线程中有多少个子线程组：" + listGroup.length + " 名字为：" + listGroup[0].getName());
            Thread[] listThread = new Thread[listGroup[0].activeCount()];
            listGroup[0].enumerate(listThread);
            System.out.println(listThread[0].getName());
    
        }

线程组自动归属特性：

public static void main(String[] args) {
            System.out.println("A处线程：" + Thread.currentThread().getName()
                    + " 所属的线程组名为：" + Thread.currentThread().getThreadGroup().getName()
                    + " 中有线程组数量：" + Thread.currentThread().getThreadGroup().activeGroupCount());
    
            ThreadGroup group = new ThreadGroup("新的组");
    
            System.out.println("A处线程：" + Thread.currentThread().getName()
                    + " 所属的线程组名为：" + Thread.currentThread().getThreadGroup().getName()
                    + " 中有线程组数量：" + Thread.currentThread().getThreadGroup().activeGroupCount());
    
            ThreadGroup[] threadGroup = new ThreadGroup[Thread.currentThread().getThreadGroup().activeGroupCount()];
            Thread.currentThread().getThreadGroup().enumerate(threadGroup);
            for (int i = 0; i < threadGroup.length; i++) {
                System.out.println("第一个线程组名称为：" + threadGroup[i].getName());
            }
    
        }
    A处线程：main 所属的线程组名为：main 中有线程组数量：0
    A处线程：main 所属的线程组名为：main 中有线程组数量：1
    第一个线程组名称为：新的组

线程组的线程批量停止：

new ThreadGroup("组名称").interrupt();

线程组异常：一个线程异常不会停止组内其他线程，如果需要一个线程出现异常后停止所有的线程组线程，需要继承ThreadGroup类重写uncaughtException()方法。

class MyThreadGroup extends ThreadGroup {
    
        public MyThreadGroup(String name) {
            super(name);
        }
    
        /**
         * 重写该方法后，线程组内的线程对象run方法内部不能在有异常catch语句，否则该方法不生效
         * @param t
         * @param e
         */
        @Override
        public void uncaughtException(Thread t, Throwable e) {
            super.uncaughtException(t, e);
            this.interrupt();
        }
    }
    class MyThread extends Thread {
        private String num;
    
        public MyThread(ThreadGroup group, String name, String num) {
            super(group, name);
            this.num = num;
        }
    
        @Override
        public void run() {
            int numInt = Integer.parseInt(num);
            while (this.isInterrupted() == false) {
                System.out.println("死循环中：" + Thread.currentThread().getName());
            }
        }
    }
    
    public class Run5_threadGroup2 {
        public static void main(String[] args) {
            MyThreadGroup group = new MyThreadGroup("线程组");
            MyThread[] threads = new MyThread[10];
            for (int i = 0; i < threads.length; i++) {
                threads[i] = new MyThread(group, "线程" + (i + 1), "1");
                threads[i].start();
            }
            MyThread newT = new MyThread(group, "线程报错", "a");
            newT.start();
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/2ecd5b3a5f4b46b192b550fd76e57c72.png