Follow these steps to implement the example:

1. First, extend the ThreadGroup class by creating a class called MyThreadGroup that would be extended from ThreadGroup. You have to declare a constructor with one parameter because the ThreadGroup class doesn't have a constructor without it. Extend the ThreadGroup class to override the uncaughtException() method in order to process the exceptions thrown by the threads of the group:

        public class MyThreadGroup extends ThreadGroup { 
          public MyThreadGroup(String name) { 
            super(name); 
          }

2. Override the uncaughtException() method. This method is called when an exception is thrown in one of the threads of the ThreadGroup class. In this case, the method will write information about the exception and the thread that throws it; it will present this information in the console. Also, note that this method will interrupt the rest of the threads in the ThreadGroup class:

        @Override 
        public void uncaughtException(Thread t, Throwable e) { 
          System.out.printf("The thread %s has thrown an Exception
",
                            t.getId()); 
          e.printStackTrace(System.out); 
          System.out.printf("Terminating the rest of the Threads
"); 
          interrupt(); 
        }

3. Create a class called Task and specify that it implements the Runnable interface:

        public class Task implements Runnable {

4. Implement the run() method. In this case, we will provoke an AritmethicException exception. For this, we will divide 1,000 with random numbers until the random generator generates zero to throw the exception:

        @Override 
        public void run() { 
          int result; 
          Random random=new Random(Thread.currentThread().getId()); 
          while (true) { 
            result=1000/((int)(random.nextDouble()*1000000000)); 
            if (Thread.currentThread().isInterrupted()) { 
              System.out.printf("%d : Interrupted
",
                                Thread.currentThread().getId()); 
              return; 
            } 
          } 
        }

5. Now, implement the main class of the example by creating a class called Main and implement the main() method:

        public class Main { 
          public static void main(String[] args) {

6. First, calculate the number of threads you are going to launch. We use the availableProcessors() method of the Runtime class (we obtain the runtime object associated with the current Java application with the static method, called getRuntime(), of that class). This method returns the number of processors available to the JVM, which is normally equal to the number of cores of the computer that run the application:

        int numberOfThreads = 2 * Runtime.getRuntime()
                                      .availableProcessors();

7. Create an object of the MyThreadGroup class:

        MyThreadGroup threadGroup=new MyThreadGroup("MyThreadGroup");

8. Create an object of the Task class:

        Task task=new Task();

9. Create the calculated number of Thread objects with this Task class and start them:

        for (int i = 0; i < numberOfThreads; i++) { 
          Thread t = new Thread(threadGroup, task); 
          t.start(); 
        }

10. Then, write information about ThreadGroup in the console:

        System.out.printf("Number of Threads: %d
",
                          threadGroup.activeCount()); 
        System.out.printf("Information about the Thread Group
"); 
        threadGroup.list();

11. Finally, write the status of the threads that form the group:

            Thread[] threads = new Thread[threadGroup.activeCount()]; 
            threadGroup.enumerate(threads); 
            for (int i = 0; i < threadGroup.activeCount(); i++) { 
              System.out.printf("Thread %s: %s
", threads[i].getName(),
                                threads[i].getState()); 
            } 
          } 
        }

12. Run the example and see the results.