为什么单线程java程序有这么多的线程？

Question

我有一个java程序有13个线程，但其中只有一个是在99％的CPU使用率，并已运行约24小时。其他的CPU使用率为0.0％，并显示从0:00.0到0:12.82之间的任一位置的TIME+，另一个则为3:51.48。该程序旨在成为一个单线程程序，所以我想知道为什么其他线程在那里？

他们在做什么，为什么他们显示如此小的CPU使用率和TIME +？

更新：我有一个旧的Java程序我写的（第一个程序 - 不要审判我！），它是单线程的，并显示了相同类型的线程使用的...

import java.io.*; 

class xdriver { 
    static int N = 100; 
    static double pi = 3.141592653589793; 
    static double one = 1.0; 
    static double two = 2.0; 

    public static void main(String[] args) { 
    //System.out.println("Program has started successfully\n"); 

    if(args.length == 1) { 
     // assume that args[0] is an integer 
     N = Integer.parseInt(args[0]); 
    } 

    // maybe we can get user input later on this ... 
    int nr = N; 
    int nt = N; 
    int np = 2*N; 

    double dr = 1.0/(double)(nr-1); 
    double dt = pi/(double)(nt-1); 
    double dp = (two*pi)/(double)(np-1); 

    System.out.format("nn --> %d\n", nr*nt*np); 

    if(nr*nt*np < 0) { 
     System.out.format("ERROR: nr*nt*np = %d(long) which is %d(int)\n", (long)((long)nr*(long)nt*(long)np), nr*nt*np); 
     System.exit(1); 
    } 

    // inserted to artificially blow up RAM 
    double[][] dels = new double [nr*nt*np][3]; 

    double[] rs = new double[nr]; 
    double[] ts = new double[nt]; 
    double[] ps = new double[np]; 

    for(int ir = 0; ir < nr; ir++) { 
     rs[ir] = dr*(double)(ir); 
    } 
    for(int it = 0; it < nt; it++) { 
     ts[it] = dt*(double)(it); 
    } 
    for(int ip = 0; ip < np; ip++) { 
     ps[ip] = dp*(double)(ip); 
    } 

    double C = (4.0/3.0)*pi; 
    C = one/C; 

    double fint = 0.0; 
    int ii = 0; 
    for(int ir = 0; ir < nr; ir++) { 
     double r = rs[ir]; 
     double r2dr = r*r*dr; 
     for(int it = 0; it < nt; it++) { 
     double t = ts[it]; 
     double sint = Math.sin(t); 
     for(int ip = 0; ip < np; ip++) { 
      fint += C*r2dr*sint*dt*dp; 

      dels[ii][0] = dr; 
      dels[ii][1] = dt; 
      dels[ii][2] = dp; 
     } 
     } 
    } 

    System.out.format("N ........ %d\n", N); 
    System.out.format("fint ..... %15.10f\n", fint); 
    System.out.format("err ...... %15.10f\n", Math.abs(1.0-fint)); 
    } 
} 

Answer 1

引用讨论完成here等研究。

几个核心JVM线程：

1. 连接监听器：这是线程总是监听其他JVM线程发送请求。 DynaTrace等生产级应用程序监控工具的一个实例就是分析或者（我不是这个问题）。
2. 信号接线员：当OS发出信号到JVM，信号调度线程将信号传递到相应的处理。
3. 指向处理器：高优先级的线程挂起排队参考。 GC创建一个需要处理的引用的简单链接列表，并且该线程将其快速添加到适当的队列中，并通知ReferenceQueue侦听器。
4. 终结者：终结者线程调用终结器方法。
5. DestroyJavaVM：这个线程上卸载程序退出Java虚拟机。大部分时间应该等待。
6. 垃圾收集器：线程负责Java的垃圾回收机制，这取决于如果GC被启用。
7. 主：主线程中运行你的含main方法程序。要注意

一个重要的一点是，这将取决于JVM实现，多少和哪些所有核心线程就会启动，但即使Java程序被写入是单线程的，将有超过JVM中有一个线程。

Java程序可以是单线程的，但是JVM（它将运行用户定义的Java程序）是多线程的，并且即使从一开始就具有多于一个的线程（至少对于最新的JVM）。

下面是我的Java HotSpot的（TM）客户端虚拟机版本24.55-B03的快照，运行单线程的Java程序：

回答您的查询

他们正在做什么和为什么他们显示如此小的CPU使用率和时间+？

哪一部分：有开始由JVM目的，像上面这样JVM想听如有分析或监控程序需要从JVM得到了一些细节解释。
为什么部分：因为他们真的不积极或正在运行的，他们是在等待或停放状态（见附件我的快照的黄线，如果你有一个GUI监控应用程序，那么你也应该看到黄色或否则，如果命令然后线程处于WAIT状态），所以它们不占用任何或最少的CPU周期，因此CPU占用率也较低。 再次TIME+会告诉你他们一直处于活动状态的时间，并且由于它们不是，所以这个参数也少。

希望这会有所帮助！

Answer 2

最有可能的线程已经在某个地方创建过，并且从未使用过。

例如：

ExecutorService es = Executors.newFixedThreadPool(12); 
// burn cpu, using only one thread (main) 
int i = 0; 
while(true) { 
    i++; 
} 

Answer 3

TIME+从顶部的CPU时间花费的金额。一种解释是，如果某个进程持续受阻或只是始终被阻止，则会导致CPU使用率较低，并且出现较低的TIME+。

Answer 4

启动Java程序意味着启动一个JVM并告诉它运行哪个主类（通常具有静态主方法）。

除了上面提到的主线程，这个JVM还产生了几个后台线程。

其中有

• 的VM线程：一个观察线程等待需要虚拟机是在一个安全点的任务。例如，有一个完全“阻止世界”的垃圾收集任务。但也有其他人。
• GC线程：多个线程被维护来运行垃圾回收。
• 编译线程：这些线程用于将字节码编译为本机机器码。

可能还有更多。

此外，如果您使用的是AWT或Swing，那么您将从这些框架中获得更多线程。其中之一就是所谓的事件调度员（EDT）。当然 - 可能有你创建并运行的线程：定时器，执行程序或简单的任意线程。即使对于一个简单的Hello World应用程序，也可能有十几个线程正在运行。

但大多数这些线程比做某事更多等待。所以很可能只有一个线程真正工作，因此利用一些CPU。

虽然... 100％的CPU利用率可能是一些问题的指标。例如，一个永无止境的循环。你必须使用一个分析器来找出真正发生的事情。但它可能只是一个具有这种CPU利用率的程序。你的判断。