Anzeigen aller Threadgruppen und Threads, die derzeit in JVM ausgeführt werden

Question

Meine Aufgabe besteht also darin, alle Threadgruppen und alle Threads anzuzeigen, die zu diesen Gruppen gehören, die derzeit in der JVM ausgeführt werden.

Dies sollte ausgegeben werden, so dass die Fadengruppe zuerst angezeigt wird und dann alle Laufflächen in dieser Gruppe darunter angezeigt werden. Dies geschieht für alle Thread-Gruppen. Derzeit wird mein Code nur alle Thread-Gruppen und dann jeden Thread anzeigen, aber ich bin mir nicht sicher, wie ich den Output erreichen kann, den ich beschrieben habe.

Hier ist meine aktuellen Code:

public ThreadGroup getThreadRoot() { 
    ThreadGroup rootGroup = Thread.currentThread().getThreadGroup(); 
    ThreadGroup parentGroup; 
    while ((parentGroup = rootGroup.getParent()) != null) { 
     rootGroup = parentGroup; 
    } 
    return rootGroup; 
} 

public ThreadGroup[] getAllThreadGroups(){ 


    ThreadGroup root= getThreadRoot(); 
    int estimate = root.activeGroupCount(); 
    ThreadGroup [] threads = new ThreadGroup[estimate]; 
    while (root.enumerate(threads, true) == threads.length) { 
     threads = new ThreadGroup[ threads.length * 2 ]; 
    } 


    ThreadGroup[] allGroups = new ThreadGroup[threads.length+1]; 
    allGroups[0] = root; 
    System.arraycopy(threads, 0, allGroups, 1, estimate); 
    return allGroups; 

} 
public Thread[] getAllThreads(){ 

    ThreadGroup root= getThreadRoot(); 
    int estimate = root.activeGroupCount(); 
    Thread [] allThreads = new Thread[estimate]; 
    while (root.enumerate(allThreads, true) == allThreads.length) { 
     allThreads = new Thread[ allThreads.length * 2 ]; 
    } 


    return allThreads; 

} 

und die wichtigste Methode:

public static void main(String[] args) { 

    CreateDummyGroups create = new CreateDummyGroups(); 
    Functionality func = new Functionality(); 
    ThreadGroup[] tg = func.getAllThreadGroups(); 
    Thread[] t = func.getAllThreads(); 
    for (int i=0; i<tg.length; i++) { 
     if(tg[i] != null){ 
     System.out.println("Name: " + tg[i].getName()); 
     } 
    } 
    for (int i=0; i<t.length; i++) { 
     if(t[i] != null){ 
     System.out.println("Name: " + t[i].getName() + ", id: " + t[i].getId() 
       + ", State: " + t[i].getState() + ", Is daemon? " + t[i].isDaemon()); 
     } 
} 
} 

} 

Answer 1

Vor allem für die einfachste Lösung, um eine hierarchische Ausgabe aller Fadengruppen und Themen zu bekommen, Sie nur benötigen getThreadRoot() Methode:

Functionality func = new Functionality(); 
func.getThreadRoot().list(); 

wird es jedoch sogar drucken die Gruppen hierarchisch statt einer Liste von Gruppen mit nur den Threads als Kinder. Dazu müssen Sie Nest Loops, das heißt

CreateDummyGroups create = new CreateDummyGroups(); 
Functionality func = new Functionality(); 
ThreadGroup[] tg = func.getAllThreadGroups(); 
Thread[] t = func.getAllThreads(); 
for(int i=0; i<tg.length; i++) { 
    if(tg[i] != null) { 
     System.out.println("Name: " + tg[i].getName()); 
     for(int j=0; j<t.length; j++) { 
      if(t[j] != null && t[j].getThreadGroup() == tg[i]) { 
      System.out.println(" Name: " + t[j].getName() + ", id: " + t[j].getId() 
        + ", State: " + t[j].getState() + ", Is daemon? " + t[j].isDaemon()); 
      } 
     } 
    } 
} 

Dieses verwendet einen Referenz Vergleich in der inneren Schleife, um nur die Fäden der aktuellen Gruppe zu zeigen. Effizienter wäre nur auf das Gewinde der aktuellen Gruppe an erster Stelle zu bekommen, das heißt, ein Verfahren zu Ihrer Functionality hinzufügen:

public Thread[] getThreadsOf(ThreadGroup group) { 
    int estimate = group.activeCount(); 
    Thread[] groupThreads = new Thread[estimate]; 
    while(group.enumerate(groupThreads, false) == groupThreads.length) { 
     groupThreads = new Thread[ groupThreads.length * 2 ]; 
    } 
    return groupThreads; 
} 

und ändern Sie den Anrufer zu

CreateDummyGroups create = new CreateDummyGroups(); 
Functionality func = new Functionality(); 
ThreadGroup[] tg = func.getAllThreadGroups(); 
for(int i=0; i<tg.length; i++) { 
    if(tg[i] != null) { 
     System.out.println("Name: " + tg[i].getName()); 
     Thread[] t = func.getThreadsOf(tg[i]); 
     for(int j=0; j<t.length; j++) { 
      if(t[j] != null) { 
      System.out.println(" Name: " + t[j].getName() + ", id: " + t[j].getId() 
        + ", State: " + t[j].getState() + ", Is daemon? " + t[j].isDaemon()); 
      } 
     } 
    } 
} 

By the way, da Java 5, kann dies gut als

CreateDummyGroups create = new CreateDummyGroups(); 
Functionality func = new Functionality(); 
for(ThreadGroup tg: func.getAllThreadGroups()) { 
    if(tg != null) { 
     System.out.println("Name: " + tg.getName()); 
     for(Thread t: func.getThreadsOf(tg)) { 
      if(t != null) { 
       System.out.println(" Name: " + t.getName() + ", id: " + t.getId() 
        + ", State: " + t.getState() + ", Is daemon? " + t.isDaemon()); 
      } 
     } 
    } 
} 

Aber beachten Sie geschrieben werden, dass diese alten enumerate Methoden dringend abgeraten werden. Sie sind nicht nur kompliziert zu verwenden, sondern auch fehleranfällig, da sich die Threads und Gruppen während der Verarbeitung ändern können. Es ist viel einfacher und zuverlässiger auf einem einzigen Schnappschuss zu einem Zeitpunkt gemacht zu arbeiten:

CreateDummyGroups create = new CreateDummyGroups(); 
Map<ThreadGroup, List<Thread>> map = new LinkedHashMap<>(); 
for(Thread thread: Thread.getAllStackTraces().keySet()) { 
    List<Thread> list = map.get(thread.getThreadGroup()); 
    if(list == null) { 
     list = new ArrayList<>(); 
     map.put(thread.getThreadGroup(), list); 
    } 
    list.add(thread); 
} 


for(Map.Entry<ThreadGroup,List<Thread>> groupEntry: map.entrySet()) { 
    System.out.println("Name: " + groupEntry.getKey().getName()); 
    for(Thread thread: groupEntry.getValue()) { 
     System.out.println(" Name: " + thread.getName() + ", id: " + thread.getId() 
      + ", State: " + thread.getState() + ", Is daemon? " + thread.isDaemon()); 
    } 
} 

Diese Logik wird noch einfacher, wenn mit Hilfe von Java 8 Funktionen:

CreateDummyGroups create = new CreateDummyGroups(); 
Map<ThreadGroup, List<Thread>> map = Thread.getAllStackTraces().keySet() 
    .stream().collect(Collectors.groupingBy(Thread::getThreadGroup)); 


map.forEach((group,threadList) -> { 
    System.out.println("Name: " + group.getName()); 
    threadList.forEach(thread -> 
     System.out.println(" Name: " + thread.getName() + ", id: " + thread.getId() 
      + ", State: " + thread.getState() + ", Is daemon? " + thread.isDaemon()) 
    ); 
});