Java Signal实例

转载 2015年07月08日 16:22:01


http://wangym.iteye.com/blog/733693

TimYang在博文《降低应用latency方法谈》 中提到对Java方法进行Profiling,在某些场景更倾向于采用纯Java工具类的方法,比如通过给进程发Signals来实现,以求动态地打开或关闭Profiler。

 

感觉这个思路不错,以下是一个大致实例:

 

SignalTest.java

 

Java代码 复制代码 收藏代码
  1. /** 
  2.  *  
  3.  */  
  4. package signal;  
  5.   
  6. import java.util.Observable;  
  7. import java.util.Observer;  
  8. import sun.misc.Signal;  
  9. import sun.misc.SignalHandler;  
  10.   
  11. /** 
  12.  * @author xuanyin 
  13.  *  
  14.  */  
  15. public class SignalTest implements Observer {  
  16.   
  17.     /** 
  18.      * @param args 
  19.      */  
  20.     public static void main(String[] args) {  
  21.   
  22.         new SignalTest().go();  
  23.     }  
  24.   
  25.     private void go() {  
  26.   
  27.         try {  
  28.   
  29.             HandlerTest sh = new HandlerTest();  
  30.             sh.addObserver(this);  
  31.             sh.handleSignal("HUP");  
  32.             sh.handleSignal("BUS");  
  33.             System.out.println("Sleeping for 60 seconds: hit me with signals!");  
  34.             Thread.sleep(60000);  
  35.   
  36.         } catch (Throwable x) {  
  37.   
  38.             x.printStackTrace();  
  39.         }  
  40.     }  
  41.   
  42.     /** 
  43.      *  
  44.      */  
  45.     @Override  
  46.     public void update(Observable arg0, Object arg1) {  
  47.   
  48.         System.out.println("Received signal: " + arg1);  
  49.     }  
  50.   
  51.     /** 
  52.      * HandlerTest Class 
  53.      */  
  54.     class HandlerTest extends Observable implements SignalHandler {  
  55.   
  56.         @Override  
  57.         public void handle(Signal signal) {  
  58.   
  59.             setChanged();  
  60.             notifyObservers(signal);  
  61.         }  
  62.   
  63.         /** 
  64.          *  
  65.          * @param signalName 
  66.          * @throws IllegalArgumentException 
  67.          */  
  68.         public void handleSignal(String signalName) throws IllegalArgumentException {  
  69.   
  70.             try {  
  71.   
  72.                 Signal.handle(new Signal(signalName), this);  
  73.   
  74.             } catch (IllegalArgumentException x) {  
  75.   
  76.                 throw x;  
  77.   
  78.             } catch (Throwable x) {  
  79.   
  80.                 throw new IllegalArgumentException("Signal unsupported: "+signalName, x);  
  81.             }  
  82.         }  
  83.     }  
  84.   
  85. }  

 

首先运行执行上述程序,然后查看其系统进程号。

如,若是4089,则在终端中执行kill -s BUS 4089

Java程序输出:Received signal: SIGBUS

 

信号具有平台相关性,不同平台下能使用的信号种类是有差异的。

 

Linux下支持的信号:

SEGV, ILL, FPE, BUS, SYS, CPU, FSZ, ABRT, INT, TERM, HUP, USR1, USR2, QUIT, BREAK, TRAP, PIPE

Windows下支持的信号:

SEGV, ILL, FPE, ABRT, INT, TERM, BREAK

 

不足之处欢迎大家留言指正:)


======================

http://blog.csdn.net/raintungli/article/details/7310141

在java 中调用Signal的方法handle可以去注册一个信号的处理函数,方法的如下:

  1.  public static synchronized SignalHandler handle(Signal sig,   
  2.                             SignalHandler handler) {  
  3. ....  
  4. }  


比如常用的addShutdownHook钩子函数里,就是在 Terminator.setup();的时候将Shutdown.exit 的函数注册到了信号SHUTDOWN1_SIGNAL(SIGHUP),SHUTDOWN2_SIGNAL(SIGINT),SHUTDOWN3_SIGNAL(SIGTERM)中,当线程接受到信号时,通过调用函数Shutdown.exit的调用hook中的钩子函数。

在笔者的文章(java 中关于信号的处理在linux下的实现)也提到jdk如何处理信号的,那么调用handle里是不是直接就把这个方法注册进了信号处理呢?

请注意,handle是一个java的方法,而注册信号函数是c的代码,显然不能简单的将java的方法直接提供给c调用,其次信号处理函数是在内核态中处理,安全性和执行时间的长短将影响到内核的信号调度。

先看java源码,如下面所示

  1.  public static synchronized SignalHandler handle(Signal sig,   
  2.                         SignalHandler handler)   
  3. throws IllegalArgumentException {  
  4. long newH = (handler instanceof NativeSignalHandler) ?   
  5.               ((NativeSignalHandler)handler).getHandler() : 2;  
  6. long oldH = handle0(sig.number, newH);  
  7. if (oldH == -1) {  
  8.     throw new IllegalArgumentException  
  9.     ("Signal already used by VM: " + sig);  
  10. }  
  11. signals.put(new Integer(sig.number), sig);  
  12. synchronized (handlers) {  
  13.     SignalHandler oldHandler = (SignalHandler)handlers.get(sig);  
  14.     handlers.remove(sig);  
  15.     if (newH == 2) {  
  16.         handlers.put(sig, handler);           
  17.     }  
  18.     if (oldH == 0) {  
  19.         return SignalHandler.SIG_DFL;  
  20.     } else if (oldH == 1) {  
  21.         return SignalHandler.SIG_IGN;  
  22.     } else if (oldH == 2) {  
  23.         return oldHandler;  
  24.     } else {  
  25.         return new NativeSignalHandler(oldH);  
  26.     }  
  27. }  
  28.    }  

在native code hand0里并没有将handle的方法传进去,只是传了一个整型值。

在c++代码中hand0里调用了函数 JVM_RegisterSignal,具体来看一下这个函数的实现

  1. JVM_ENTRY_NO_ENV(void*, JVM_RegisterSignal(jint sig, void* handler))  
  2.   // Copied from classic vm  
  3.   // signals_md.c       1.4 98/08/23  
  4.   void* newHandler = handler == (void *)2  
  5.                    ? os::user_handler()  
  6.                    : handler;  
  7.   switch (sig) {  
  8.     /* The following are already used by the VM. */  
  9.     case INTERRUPT_SIGNAL:  
  10.     case SIGFPE:  
  11.     case SIGILL:  
  12.     case SIGSEGV:  
  13.   
  14.     /* The following signal is used by the VM to dump thread stacks unless 
  15.        ReduceSignalUsage is set, in which case the user is allowed to set 
  16.        his own _native_ handler for this signal; thus, in either case, 
  17.        we do not allow JVM_RegisterSignal to change the handler. */  
  18.     case BREAK_SIGNAL:  
  19.       return (void *)-1;  
  20.   
  21.     /* The following signals are used for Shutdown Hooks support. However, if 
  22.        ReduceSignalUsage (-Xrs) is set, Shutdown Hooks must be invoked via 
  23.        System.exit(), Java is not allowed to use these signals, and the the 
  24.        user is allowed to set his own _native_ handler for these signals and 
  25.        invoke System.exit() as needed. Terminator.setup() is avoiding 
  26.        registration of these signals when -Xrs is present. 
  27.        - If the HUP signal is ignored (from the nohup) command, then Java 
  28.          is not allowed to use this signal. 
  29.      */  
  30.   
  31.     case SHUTDOWN1_SIGNAL:  
  32.     case SHUTDOWN2_SIGNAL:  
  33.     case SHUTDOWN3_SIGNAL:  
  34.       if (ReduceSignalUsage) return (void*)-1;  
  35.       if (os::Linux::is_sig_ignored(sig)) return (void*)1;  
  36.   }  
  37.   
  38.   void* oldHandler = os::signal(sig, newHandler);  
  39.   if (oldHandler == os::user_handler()) {  
  40.       return (void *)2;  
  41.   } else {  
  42.       return oldHandler;  
  43.   }  
  44. JVM_END  


  1. void* newHandler = handler == (void *)2  
  2.                    ? os::user_handler()  
  3.                    : handler;  

因为传进的值是2,那么真正在c++里的信号处理函数实际上os::user_handler(),同时jvm也保护了几个信号,不允许外部改变信号的处理函数。

一切豁然开朗,笔者的博客(java 中关于信号的处理在linux下的实现)已经提到过这个函数,通过os:signal_notify 去通知signal dispatcher 线程的os::signal_wait,也就是接受到信号的线程通过信号函数notify到处理信号的线程(signal dispatcher ),最后由该线程做后续的事情。

具体来看signal dispatcher 的thread entry

  1. static void signal_thread_entry(JavaThread* thread, TRAPS) {  
  2.       ....  
  3.       default: {  
  4.         // Dispatch the signal to java  
  5.         HandleMark hm(THREAD);  
  6.         klassOop k = SystemDictionary::resolve_or_null(vmSymbolHandles::sun_misc_Signal(), THREAD);  
  7.         KlassHandle klass (THREAD, k);  
  8.         if (klass.not_null()) {  
  9.           JavaValue result(T_VOID);  
  10.           JavaCallArguments args;  
  11.           args.push_int(sig);  
  12.           JavaCalls::call_static(  
  13.             &result,  
  14.             klass,  
  15.             vmSymbolHandles::dispatch_name(),  
  16.             vmSymbolHandles::int_void_signature(),  
  17.             &args,  
  18.             THREAD  
  19.           );  
  20.         }  
  21.         ....  
  22. }  


也就是在jvm的c++源码中,反调用了java的方法,也就是signal.java中的dispatch(int number),方法dispatch中才是真正的调用了在文章开头提到的注册到Signal的方法handle。

dispatch方法中仍然起了一个新的线程去处理handle,这样就不会block signal dispatcher 线程。

相关文章推荐

Java信号处理

信号简介 信号是在软件层次上对中断机制的一种模拟,在原理上,一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。 通俗来讲,信号就是进程间的一种异步通信机制。 典型的例子: kill ...

【java】Singal和SingalHandler用法

In my earlier article, I talked about how to do a graceful shutdown your of Java applicationwhen C...

Java线程(九):Condition-线程通信更高效的方式

接近一周没更新《Java线程》专栏了,主要是这周工作上比较忙,生活上也比较忙,呵呵,进入正题,上一篇讲述了并发包下的Lock,Lock可以更好的解决线程同步问题,使之更面向对象,并且ReadWrite...
  • ghsau
  • ghsau
  • 2012年04月20日 14:49
  • 69121

java 中关于信号的处理在linux下的实现

linux 的线程和信号 基于 NPTL 的线程库,多线程应用中的每个线程有自己独特的线程 ID,并共享同一个进程ID。应用程序可以通过调用 kill(getpid(),signo) 将信号发送到进...

java 中关于自定义信号在linux下的实现

在java 中调用Signal的方法handle可以去注册一个信号的处理函数,方法的如下: public static synchronized SignalHandler handle(Si...

Java程序优雅关闭的两种方法

使用java编写大型系统时,往往需要在程序被kill时将内存中的一些临时数据和状态处理掉,这里称之为优雅关闭。介绍两种比较典型的方法。...

Java中的await()/signal()用法

二、方法await()/signal()   在JDK5.0以后,JAVA提供了新的更加健壮的线程处理机制,包括了同步、锁定、线程池等等,可以实现更小粒度上的控制。await()和signal()就...

signal信号捕捉

Signal 顾名思义是信号的意思,为什么要用到这个东西了?原因:由于现在在负责写网游的后台loginServer,里面写了不少配置文件,当我们的产品上线后,loginServer开启后这时配置文件的...

java 捕捉信号(linux下的kill,ctrl+c)

import sun.misc.Signal;import sun.misc.SignalHandler;/**** java信号处理demo* @author jiang_qh**/public c...

Timer::signalHandle()解析

Timer::signalHandle()解析
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java Signal实例
举报原因:
原因补充:

(最多只允许输入30个字)