Java 工具（jmap,jstack）在Linux上的源码分析（二）信号处理

Java 工具（jmap,jstack）在Linux上的源码分析（二）信号处理

当java虚拟机启动的时候，会启动很多内部的线程，这些线程主要在thread.cpp里的create_vm方法体里实现

而在thread.cpp里主要起了2个线程来处理信号相关的

1. JvmtiExport::enter_live_phase();  
2.   
3. // Signal Dispatcher needs to be started before VMInit event is posted   
4. os::signal_init();  
5.   
6. // Start Attach Listener if +StartAttachListener or it can't be started lazily   
7. if (!DisableAttachMechanism) {  
8.   if (StartAttachListener || AttachListener::init_at_startup()) {  
9.     AttachListener::init();  
10.   }  
11. }  

1. Signal Dispatcher 线程

在os.cpp中的signal_init()函数中，启动了signal dispatcher 线程，对signal dispather 线程主要是用于处理信号，等待信号并且分发处理，可以详细看signal_thread_entry的方法

1. static void signal_thread_entry(JavaThread* thread, TRAPS) {  
2.   os::set_priority(thread, NearMaxPriority);  
3.   while (true) {  
4.     int sig;  
5.     {  
6.       // FIXME : Currently we have not decieded what should be the status   
7.       //         for this java thread blocked here. Once we decide about   
8.       //         that we should fix this.   
9.       sig = os::signal_wait();  
10.     }  
11.     if (sig == os::sigexitnum_pd()) {  
12.        // Terminate the signal thread   
13.        return;  
14.     }  
15.   
16.     switch (sig) {  
17.       case SIGBREAK: {  
18.         // Check if the signal is a trigger to start the Attach Listener - in that   
19.         // case don't print stack traces.   
20.         if (!DisableAttachMechanism && AttachListener::is_init_trigger()) {  
21.           continue;  
22.         }  
23.         // Print stack traces   
24.         // Any SIGBREAK operations added here should make sure to flush   
25.         // the output stream (e.g. tty->flush()) after output.  See 4803766.   
26.         // Each module also prints an extra carriage return after its output.   
27.         VM_PrintThreads op;  
28.         VMThread::execute(&op);  
29.         VM_PrintJNI jni_op;  
30.         VMThread::execute(&jni_op);  
31.         VM_FindDeadlocks op1(tty);  
32.         VMThread::execute(&op1);  
33.         Universe::print_heap_at_SIGBREAK();  
34.         if (PrintClassHistogram) {  
35.           VM_GC_HeapInspection op1(gclog_or_tty, true /* force full GC before heap inspection */,  
36.                                    true /* need_prologue */);  
37.           VMThread::execute(&op1);  
38.         }  
39.         if (JvmtiExport::should_post_data_dump()) {  
40.           JvmtiExport::post_data_dump();  
41.         }  
42.         break;  
43.       }  
44.       default: {  
45.         // Dispatch the signal to java   
46.         HandleMark hm(THREAD);  
47.         klassOop k = SystemDictionary::resolve_or_null(vmSymbolHandles::sun_misc_Signal(), THREAD);  
48.         KlassHandle klass (THREAD, k);  
49.         if (klass.not_null()) {  
50.           JavaValue result(T_VOID);  
51.           JavaCallArguments args;  
52.           args.push_int(sig);  
53.           JavaCalls::call_static(  
54.             &result,  
55.             klass,  
56.             vmSymbolHandles::dispatch_name(),  
57.             vmSymbolHandles::int_void_signature(),  
58.             &args,  
59.             THREAD  
60.           );  
61.         }  
62.         if (HAS_PENDING_EXCEPTION) {  
63.           // tty is initialized early so we don't expect it to be null, but   
64.           // if it is we can't risk doing an initialization that might   
65.           // trigger additional out-of-memory conditions   
66.           if (tty != NULL) {  
67.             char klass_name[256];  
68.             char tmp_sig_name[16];  
69.             const char* sig_name = "UNKNOWN";  
70.             instanceKlass::cast(PENDING_EXCEPTION->klass())->  
71.               name()->as_klass_external_name(klass_name, 256);  
72.             if (os::exception_name(sig, tmp_sig_name, 16) != NULL)  
73.               sig_name = tmp_sig_name;  
74.             warning("Exception %s occurred dispatching signal %s to handler"  
75.                     "- the VM may need to be forcibly terminated",  
76.                     klass_name, sig_name );  
77.           }  
78.           CLEAR_PENDING_EXCEPTION;  
79.         }  
80.       }  
81.     }  
82.   }  
83. }  

可以看到通过os::signal_wait();等待信号，而在linux里是通过sem_wait()来实现，接受到SIGBREAK(linux 中的QUIT)信号的时候（关于信号处理请参考笔者的另一篇:Java 中关于信号的处理在Linux下的实现 ），第一次通过调用 AttachListener::is_init_trigger（）初始化attach listener线程，详细见2.Attach Listener 线程。

1. 第一次收到信号，会开始初始化，当初始化成功，将会直接返回，而且不返回任何线程stack的信息（通过socket file的操作返回），并且第二次将不在需要初始化。如果初始化不成功，将直接在控制台的outputstream中打印线程栈信息。
2. 第二次收到信号，如果已经初始化过，将直接在控制台中打印线程的栈信息。如果没有初始化，继续初始化，走和第一次相同的流程。