有没有一种方法可以使用JVMTI生成定期的Java线程转储？

Question

There are multiple ways to generate thread dumps in java.

I'd like to use JVMTI (the C API) to generate it, in order to evaluate its performance impact on a running JVM. (I am aware of jstack and JMX ; this question is not generally about getting thread dumps, but about using the JVMTI API).

I'm basing my code off of this blog post . In there, the java agent attaches to the SIGQUIT signal. I'd like to avoid that, because that is the same signal that the JVM uses in order to write a thread dump to stdout. I want to avoid that duplicity.

In other words, I'd like to either attach to a different signal, or find a way for the agent to generate a thread dump periodically.

Answer 1

In there, the java agent attaches to the SIGQUIT signal. I'd like to avoid that, because that is the same signal that the JVM uses in order to write a thread dump to stdout. I want to avoid that duplicity.

Just remove the following snippet from your code

/* Set callbacks and enable event notifications */
memset(&callbacks, 0, sizeof(callbacks));
callbacks.DataDumpRequest = &dumpThreadInfo;
err = (*jvmti)->SetEventCallbacks(jvmti, &callbacks, sizeof(callbacks));
CHECK_JVMTI_ERROR(jvmti, err);
err = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,JVMTI_EVENT_DATA_DUMP_REQUEST, NULL);
CHECK_JVMTI_ERROR(jvmti, err);

I'd like to either attach to a different signal

Here is the paper, that is a bit old, but the information should be still relevant.

Just a sample of how to do a signal handling

import sun.misc.Signal;
import sun.misc.SignalHandler;

public class ThreadDumpSignalHandler implements SignalHandler {
    private volatile SignalHandler old;
    private ThreadDumpSignalHandler() {

    }
    public static void register(String sigName) {
        ThreadDumpSignalHandler h = new ThreadDumpSignalHandler();
        h.old = Signal.handle(new Signal(sigName), h)
    }
    public void handle(Signal sig) {
        threadDump();

        if(old != null && old != SIG_DFL && old != SIG_IGN) {
            old.handle(sig);
        }
    }
    // call your own threadDump native method.
    // note that in the implementation of this method you are able to access jvmtiEnv from *gdata (see below)
    private native void threadDump();
}

ThreadDumpSignalHandler.register("INT");

Of cause you can write completely native signal handler (please note that I haven't tested it, this is just an idea that should work)

static sighandler_t old_handler;
static void thread_dump_handler(int signum) {
    if(gdata && gdata->jvmti) {
        ... get thread dump
    }

    if(old_handler) {
        old_handler(signum);
    }
}

JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM *vm, char *options, void *reserved) {
    old_handler = signal(SIGINT, thread_dump_handler);

    ...
}

or find a way for the agent to generate a thread dump periodically.

In your sample there is global *gdata

typedef struct {
   /* JVMTI Environment */
   jvmtiEnv      *jvmti;
   jboolean       vm_is_started;
   /* Data access Lock */
   jrawMonitorID  lock;
} GlobalAgentData;

static GlobalAgentData *gdata;

... so, just obtain jvmtiEnv from there at any time you want (timer callbacks, etc.)

Answer 2

If your goal is to periodically collect thread dump, you can use Java Flight Recorder, that is part of Java Mission Controller

Starting with the release of Oracle JDK 7 Update 40 (7u40), Java Mission Control is bundled with the HotSpot JVM.

Answer 3

The blog entry you cite has most of what you need for JVMTI plumbing. You can use the JVMTIenv from gdata. That is legal. Make sure if you're making JNI calls to have a proper JNIenv for your current thread.

You now need to add a way to get notified to take your action (eg: thread dump). Spin up a thread that listens on a socket, uses inotify , named semaphores, etc.. - something that you can poke from outside.

You can then call dumpThreadInfo() from your event handler loop as you see fit.

Answer 4

jvmtiEventCallbacks中的所有事件都不适合（除非您想使用DataDumpRequestion，但是如果您这样做了，您将不会在这里询问：ok，所以到目前为止，这几乎就是我附加到jvm的方式（有细微差别）因此，我想这引出了下一个问题：如果不是从回调中调用GetStackTrace，如何获取指向jvmtiEnv的指针呢？