detect stuck carrier threads in java 21+ thread dumps

Author: irockel

tda/src/main/java/de/grimmfrost/tda/Analyzer.java

@@ -105,6 +105,27 @@ public String analyzeDump() {
             statData.append("<a style=\"color: ").append(linkColor).append(";\" href=\"http://www.tagtraum.com/gcviewer.html\">GCViewer-Homepage</a> for more<br>");
             statData.append(" information on how to do this.</td></tr>");
         }
+
+        // check for stuck carrier threads
+        if (threadCount > 0) {
+            int stuckCarrierThreads = 0;
+            Category threadsCat = tdi.getThreads();
+            for (int i = 0; i < threadCount; i++) {
+                javax.swing.tree.DefaultMutableTreeNode node = (javax.swing.tree.DefaultMutableTreeNode) threadsCat.getNodeAt(i);
+                ThreadInfo ti = (ThreadInfo) node.getUserObject();
+                if (ti.getContent().contains("carrier thread seems to be stuck in application code")) {
+                    stuckCarrierThreads++;
+                }
+            }
+            if (stuckCarrierThreads > 0) {
+                statData.append("<tr bgcolor=\"#ffffff\"<td></td></tr>");
+                statData.append("<tr bgcolor=\"").append(altRowColor).append("\"><td colspan=2><font face=System color=\"").append(textColor).append("\"><p>")
+                        .append("Detected ").append(stuckCarrierThreads).append(" virtual thread(s) where the carrier thread seems to be stuck in application code.</p><br>");
+                statData.append("This might indicate \"pinning\" or long-running operations on a virtual thread that prevent it from yielding.<br>");
+                statData.append("A Carrier Thread is usually named something like 'ForkJoinPool-x-Worker'.<br>");
+                statData.append("Check the <a style=\"color: ").append(linkColor).append(";\" href=\"dump://\">thread dump</a> for threads with this warning.</td></tr>");
+            }
+        }
 
         return statData.toString();
     }

tda/src/main/java/de/grimmfrost/tda/SunJDKParser.java

@@ -244,6 +244,7 @@ public MutableTreeNode parseNext() {
                                 }
                                 if (isVirtualThread) {
                                     virtualThreads++;
+                                    // Reset isVirtualThread here as we are moving to next thread
                                     isVirtualThread = false;
                                 }
                             }
@@ -307,6 +308,29 @@ public MutableTreeNode parseNext() {
                             content.append("</b></font>");
                             content.append("\n");
 
+                            // Check if carrier thread has issues (like being stuck in application code)
+                            String contentStr = content.toString();
+                            int atIdx = contentStr.indexOf("at ");
+                            if (atIdx > 0) {
+                                String stackTrace = contentStr.substring(atIdx);
+                                String[] lines = stackTrace.split("\n");
+                                boolean foundAppCode = false;
+                                for (String stackLine : lines) {
+                                    if (stackLine.contains("at ") 
+                                            && !stackLine.contains("java.lang.VirtualThread.run")
+                                            && !stackLine.contains("java.util.concurrent.ForkJoinPool")
+                                            && !stackLine.contains("java.util.concurrent.ForkJoinWorkerThread")
+                                            && !stackLine.contains("java.base@")
+                                            && !stackLine.contains("jdk.internal")) {
+                                        foundAppCode = true;
+                                        break;
+                                    }
+                                }
+                                if (foundAppCode) {
+                                    content.append("<font color=\"#ff0000\"><b>Note: carrier thread seems to be stuck in application code.</b></font>\n");
+                                }
+                            }
+
                             // Mark this platform thread as carrying a virtual thread
                             isVirtualThread = true;
 
@@ -438,6 +462,12 @@ public MutableTreeNode parseNext() {
                 ((Category) catMonitors.getUserObject()).setName(((Category) catMonitors.getUserObject()) + " (" + monitorCount + " Monitors)");
                 ((Category) catMonitorsLocks.getUserObject()).setName(((Category) catMonitorsLocks.getUserObject()) + " (" + monitorsWithoutLocksCount
                         + " Monitors)");
+                
+                if (virtualThreads > 0) {
+                    ((Category) catVirtualThreads.getUserObject()).setName(((Category) catVirtualThreads.getUserObject()) + " (" + virtualThreads + " Virtual Threads)");
+                    threadDump.add(catVirtualThreads);
+                }
+
                 // add thread dump to passed dump store.
                 if ((threadCount > 0) && (dumpKey != null)) {
                     threadStore.put(dumpKey.trim(), threads);

tda/src/main/resources/de/grimmfrost/tda/doc/README

@@ -6,6 +6,7 @@ TDA - Thread Dump Analyzer -- Version 2.7
 Note: This is the 2.7 release of the software, for an usage overview see Help/Overview.
 
 Changes from 2.6 are:
+* Detect stuck Carrier Threads in Java 21+ thread dumps.
 * Reworked the thread dump summary to provide information in a more compact way.
 * MacOS Binary is now provided.
 * Use flatplaf for a modern look and feel.

tda/src/test/java/de/grimmfrost/tda/SunJDKParserTest.java

@@ -321,6 +321,77 @@ public void testVirtualThreadDumps() throws FileNotFoundException, IOException {
         }
     }
 
+    @Test
+    public void testCarrierThreadIssuesDetection() throws FileNotFoundException, IOException {
+        System.out.println("testCarrierThreadIssuesDetection");
+        FileInputStream fis = null;
+        DumpParser instance = null;
+        
+        try {
+            fis = new FileInputStream("src/test/resources/carrier_stuck.log");
+            Map dumpMap = new HashMap();
+            Vector topNodes = new Vector();
+            instance = DumpParserFactory.get().getDumpParserForLogfile(fis, dumpMap, false, 0);
+            
+            assertTrue(instance instanceof SunJDKParser);
+
+            while (instance.hasMoreDumps()) {
+                topNodes.add(instance.parseNext());
+            }
+
+            assertEquals(1, topNodes.size());
+            DefaultMutableTreeNode dumpNode = (DefaultMutableTreeNode) topNodes.get(0);
+            
+            // Navigate to virtual threads category
+            DefaultMutableTreeNode vtCat = null;
+            for (int i = 0; i < dumpNode.getChildCount(); i++) {
+                DefaultMutableTreeNode child = (DefaultMutableTreeNode) dumpNode.getChildAt(i);
+                Object userObject = child.getUserObject();
+                if (userObject instanceof Category) {
+                    Category cat = (Category) userObject;
+                    if (cat.getName().contains("Virtual Threads")) {
+                        vtCat = child;
+                        break;
+                    }
+                }
+            }
+            
+            assertNotNull(vtCat, "Virtual Threads category should exist");
+            
+            boolean foundWarning = false;
+            for (int i = 0; i < vtCat.getChildCount(); i++) {
+                DefaultMutableTreeNode threadNode = (DefaultMutableTreeNode) vtCat.getChildAt(i);
+                Object userObject = threadNode.getUserObject();
+                String threadInfo = userObject.toString();
+                if (userObject instanceof ThreadInfo) {
+                    String content = ((ThreadInfo)userObject).getContent();
+                    if (threadInfo.contains("ForkJoinPool-1-worker-1") && content.contains("Note:")) {
+                        foundWarning = true;
+                        assertTrue(content.contains("carrier thread seems to be stuck in application code"), "Warning message should be correct");
+                    }
+                }
+            }
+            
+            assertTrue(foundWarning, "Should have found a warning note for the stuck carrier thread");
+            
+            // Now test the analyzer output
+            ThreadDumpInfo tdi = (ThreadDumpInfo) dumpNode.getUserObject();
+            Analyzer analyzer = new Analyzer(tdi);
+            String hints = analyzer.analyzeDump();
+            assertNotNull(hints, "Analysis hints should not be null");
+            assertTrue(hints.contains("carrier thread seems to be stuck in application code"), "Analysis hints should contain warning about stuck carrier thread");
+            assertTrue(hints.contains("Detected 1 virtual thread(s)"), "Analysis hints should report correct number of stuck carrier threads");
+            
+        } finally {
+            if(instance != null) {
+                instance.close();
+            }
+            if(fis != null) {
+                fis.close();
+            }
+        }
+    }
+
     @Test
     public void testLongRunningDetectionWithVariableFields() throws FileNotFoundException, IOException {
         System.out.println("testLongRunningDetectionWithVariableFields");

tda/src/test/resources/carrier_stuck.log

@@ -0,0 +1,27 @@
+2026-01-23 21:50:00
+Full thread dump OpenJDK 64-Bit Server VM (21.0.2+13-LTS mixed mode, sharing):
+
+"ForkJoinPool-1-worker-1" #11 daemon [11] prio=5 os_prio=0 cpu=5678.90ms elapsed=58230.14s tid=0x00007f8b2c158000 nid=0x1ac7 runnable  [0x00007f8b234f5000]
+   java.lang.Thread.State: RUNNABLE
+        at com.example.app.StuckService.heavyProcessing(StuckService.java:45)
+        at com.example.app.StuckService.process(StuckService.java:25)
+        at java.lang.VirtualThread.run(java.base@21.0.2/VirtualThread.java:309)
+        at java.util.concurrent.ForkJoinPool.runWorker(java.base@21.0.2/ForkJoinPool.java:1519)
+        at java.util.concurrent.ForkJoinWorkerThread.run(java.base@21.0.2/ForkJoinWorkerThread.java:165)
+   Carrying virtual thread #21
+
+"VirtualThread[#21]" #21 virtual [21] prio=5 os_prio=0 cpu=45.23ms elapsed=12345.67s tid=0x00007f8b2c200000 nid=0x1ac8 runnable  [0x0000000000000000]
+   java.lang.Thread.State: RUNNABLE
+        at com.example.app.StuckService.heavyProcessing(StuckService.java:45)
+        at com.example.app.StuckService.process(StuckService.java:25)
+        at java.lang.VirtualThread.run(java.base@21.0.2/VirtualThread.java:309)
+
+"ForkJoinPool-1-worker-2" #12 daemon [12] prio=5 os_prio=0 cpu=100.00ms elapsed=58230.14s tid=0x00007f8b2c159000 nid=0x1ac8 waiting on condition  [0x00007f8b233f4000]
+   java.lang.Thread.State: WAITING (parking)
+        at jdk.internal.misc.Unsafe.park(java.base@21.0.2/Native Method)
+        at java.util.concurrent.locks.LockSupport.park(java.base@21.0.2/LockSupport.java:211)
+        at java.util.concurrent.ForkJoinPool.awaitWork(java.base@21.0.2/ForkJoinPool.java:1565)
+        at java.util.concurrent.ForkJoinPool.runWorker(java.base@21.0.2/ForkJoinPool.java:1519)
+        at java.util.concurrent.ForkJoinWorkerThread.run(java.base@21.0.2/ForkJoinWorkerThread.java:165)
+
+"VM Periodic Task Thread" os_prio=0 cpu=67892.34ms elapsed=58234.15s tid=0x00007f8b2c18f000 nid=0x1aca waiting on condition