JVM中的监听信号的线程以及Unix域套接字通信的线程-技术圈

【实验】

package com.infuq.tmp;
public class Main {    public static void main(String args[]) {        for (;;) {            try {                Thread.sleep(5000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}

以上代码中,让JVM不退出,我们对它做点手脚,看一下JVM中的两个线程.

编译之后运行它.

通过jps查看进程号=6617

查看进程6617的线程
ps -Lf 6617

共计20个轻量级进程(LWP),即线程.

也可以通过/proc/6617/task查看进程6617下有多少个任务(即线程), 也是20个线程,如下.

我们再看一下这个进程6617打开的文件描述符,如下
ls -l /proc/6617/fd

共计6个文件描述符, 0,1,2分别是标准输入,标准输出和标准错误输出. 3,4,5描述符表示打开的3个jar.

总结一下,此时的JVM里面,共计20个线程,进程打开了6个文件描述符.

面试题: 如何知道JVM中的线程个数,有哪些方法?

接下来,我们在/tmp目录下创建一个.attach_pid6617文件,如下

接下来,我们使用kill命令向进程发送退出信号.

说明: 信号机制是进程间通信的一种方式

再观察下线程的信息

多了一个6666的线程.

再看下进程6617打开的文件描述符

会发现多了一个文件描述6,而且还是个socket文件描述符.

总结一下,使用kill命令向JVM进程发送一个退出信号, 结果JVM多了1个线程,还多了1个sokcet文件描述符.

进程间通信的方式有很多,其中信号就是其中一种方式. 关于进程间的通信可以阅读它[ https://www.yuque.com/infuq/language/rvdvcu ] . 向JVM发送一个信号之后,那么JVM必然有一个线程来处理信号,而这个线程就是Signal Dispatcher线程.

我相信,读者朋友,通过jstack命令查看线程栈的时候,一定能看到这个线程.

Signal Dispatcher线程在JVM启动的时候就创建了. 关于JVM的启动,我们先在这里简单说一下.

在jdk/src/share/bin/main.c文件中,有个main方法,它是一切的源头,JVM就是从这里开始它的人生之旅的,经过一路小跑,会创建main线程,也会创建JVM. 还会创建Signal Dispatcher线程,Signal Dispatcher线程会阻塞等待接收外部的信号. 比如上文中,我们使用kill向指定的进程6617发送的3号退出信号,就是由进程6617中的Signal Dispatcher线程来处理的. Signal Dispatcher线程在收到并处理3号退出信号的时候,它会创建Attach Listener线程,也会创建一个socket文件描述符,这个socket文件描述符就是上文中看到的那个6号文件描述符,那么这个socket文件描述符能干啥用呢?

除了信号可以用于进程间通信, Unix Domain Socket也可以用于进程间通信. 这种socket有别于网络socket. Unix Domain Socket仅用于本地进程间通信, 而网络socket用于网络间的进程间通信. 而通过Unix Domain Socket创建出来的6号文件描述符,它就是由Attach Listener这个线程来使用的. 这个Attach Listener线程作为服务端,监听客户端的请求. 比如像jstack命令,阿里的Arthas(阿尔萨斯)等工具,它们底层都是通过这个socket文件描述符连接到目标JVM,从而实现通信.

我们通过JDK自带的bin目录下的工具jvisualvm,通过图形化的方式,再次查看下进程6617中的线程.

看看你公司的服务器是否有这两个线程呢?

接下来我们通过3种方式获取进程6617的线程栈信息.

面试题: 如何得到一个进程的线程栈信息?

第一种方式就是通过jstack命令,或者JDK体系的其他命令.

第二种方式,通过Java代码的方式

import com.sun.tools.attach.VirtualMachine;import sun.tools.attach.HotSpotVirtualMachine;import java.io.InputStream;
public class Attach {    public static void main(String[] args)throws Exception {        // attach底层就是发送了一个kill -3 6617的命令给目标JVM        VirtualMachine virtualMachine = VirtualMachine.attach("6617");        HotSpotVirtualMachine hotSpotVirtualMachine = (HotSpotVirtualMachine)virtualMachine;        // 发送threaddump命令给目标JVM        InputStream inputStream = hotSpotVirtualMachine.remoteDataDump(new String[]{});
        byte[] buff = new byte[256];        int len;        do {            // 接收目标JVM返回的数据            len = inputStream.read(buff);            if (len > 0) {                String respone = new String(buff, 0, len, "UTF-8");                System.out.print(respone);            }        } while(len > 0);
        inputStream.close();        virtualMachine.detach();    }}

编译并运行这个Java程序,依然可以得到进程6617的线程栈信息

第三种方式,通过C语言的方式, 之所以通过C语言的方式,旨在说明一点,不管我们使用的是jstack命令,还是上面的Java程序,或者阿里开源的Arthas(阿尔萨斯)工具,在它们的底层,都是通过同一种方式与目标JVM进行通信的, 而通过C语言,能更好的把它展现给我们看.

个人理解: 如果真想把JVM或者JDK学透了,C语言是要熟悉的. JVM的底层都是C语言,包括与操作系统的一些交互,都是C语言. 包括进程间的通信等, 如果不懂C语言,不懂一些操作系统的知识,那么很难学透JVM或者JDK. 之所以要学习JVM等底层知识, 个人理解,主要是让我们的知识体系健全,不至于知识碎片化.

代码如下

// threaddump.c#include <stdio.h>#include <stdlib.h>#include <string.h>#include <sys/stat.h>#include <sys/socket.h>#include <sys/types.h>#include <sys/un.h>#include <errno.h>#include <stddef.h>#include <unistd.h>
#define BUFFER_SIZE 8192const char *filename = "/tmp/.java_pid6617";
int main(int argc, char **argv){        struct sockaddr_un  un;        int             fd;        char            buffer[BUFFER_SIZE];        char            *cmd = "1\0threaddump\0\0\0\0"; // 长度16
        un.sun_family = AF_UNIX;        strcpy(un.sun_path, filename);
        fd = socket(PF_UNIX, SOCK_STREAM, 0);        connect(fd, (struct sockaddr *) &un, sizeof(un));
        // 方式一        send(fd, cmd, 16, 0);        recv(fd, buffer, BUFFER_SIZE, 0);
        // 方式二        //write(fd, cmd, 16);        //read(fd, buffer, BUFFER_SIZE);
        printf("\n%s\n", buffer);        close(fd);        return 0;}

编译

运行

上面我们可以看到,线程栈信息正常打印出来了. 那么它是如何做到的呢?
首先,在代码中定义了一个 const char *filename = "/tmp/.java_pid6617"; 文件名, 我们看下这个文件.

6617就是进程ID. 当我们通过kill命令向JVM发送3号退出信号的时候, Signal Dispatcher线程就会把Attach Listener线程创建出来, Attach Listener线程就会根据进程ID创建一个/tmp/.java_pid<PID>的文件. 如果是网络socket通信,是基于IP和端口,而如果是Unix Domain Socket通信,就是基于文件的,而此时创建了一个/tmp/.java_pid<PID>的文件, Attach Listener线程就会创建一个服务端的socket, 那么客户端就可以根据这个/tmp/.java_pid<PID>的文件创建一个客户端,然后与服务端进行通信了. 那么如何创建客户端的socket呢?

在我们的C语言代码里

// 创建Unix Domain Socket用于本机进程间通信fd = socket(PF_UNIX, SOCK_STREAM, 0);// 连接服务器. 服务器也是通过Unix Domain Socket创建的.connect(fd, (struct sockaddr *) &un, sizeof(un));

通过以上两句,创建了客户端的socket, 并与服务端(也就是目标JVM)建立了连接, 然后就是发送命令了.
代码中我们发送了一个threaddump的命令,如下

char            *cmd = "1\0threaddump\0\0\0\0"; // 长度16

一切皆协议, 客户端和服务端约定好了, 服务端接收什么样子的命令格式才表示需要dump线程栈, 于是乎,客户端就构造这样的命令, 然后把它发送给目标JVM. 目标JVM的Attach Listener线程收到命令之后,进行处理,然后把处理结果返回给客户端, 于是乎客户端就拿到了目标JVM的线程栈.

本篇啰嗦这么多,主要就是在表达,如何与目标JVM进行通信,以及涉及的一些线程和知识点.