用Java实现JVM目录

第零章 用Java实现JVM之随便说点什么
第一章 用Java实现JVM之JVM的准备知识
第二章 用Java实现JVM之命令行工具
第三章 用Java实现JVM之查找Class文件
第四章 用Java实现JVM之解析class文件
第五章 用Java实现JVM之运行时数据区
第六章 用Java实现JVM之指令集和解释器
第七章 用Java实现JVM之类和对象
第八章 用Java实现JVM之方法调用和返回
第九章 用Java实现JVM之数组和字符串
第十章 用Java实现JVM之本地方法调用
第十一章 用Java实现JVM之异常处理
第十二章 用Java实现JVM之结束

前言

本地方法

提起“本地方法”这个词，可能很多人一时间会感到陌生：“这是什么？是指在本地调用的方法吗？”实际上，在Java的语境中，“本地方法”并不是我们日常写的普通方法，而是指由非 Java 语言（通常是 C/C++）编写的方法，然后通过JNI（Java Native Interface）的方式被Java所调用

那为什么Java需要调用C++写的方法？既然Java是跨平台的高级语言，为什么还要依赖底层语言来实现一些功能？难道Java自己不够强大吗？Java表示自己也很无奈啊。其实，这并不是Java的能力问题，而是它的边界问题。有些功能确实不是Java擅长或适合做的。比如：

• 操作系统级别的功能：Java本身是一种运行在虚拟机上的语言，和操作系统之间是隔着JVM的。但有些系统调用，比如访问硬件、操控内存地址、与驱动交互等，必须依赖原生语言，比如C/C++

• 性能要求极高的场景：C/C++在执行效率上天然比Java更靠近机器层面，比如要做一些高频率的图像处理、音视频编解码、数据库底层引擎等，使用本地方法可以显著提高性能

• 复用已有的成熟库：很多早期开发的底层库、驱动程序甚至商业SDK都是用C/C++写的，直接复用比重新用Java实现一套更划算，也更稳定

因此，本地方法实际上是Java与底层系统打交道的一座桥梁，是Java向下“伸手”的一种方式。我们可以把它理解为一种“Java自己做不了，就让专业选手（C/C++）上”的机制。这也是为什么很多涉及底层优化、系统调用、硬件控制的Java应用中，我们常常能看到native关键字的身影。它的存在就是为了告诉JVM：“这部分逻辑不是我写的，是由底层实现的，去调用对应的本地库吧。”

总之，本地方法不是 Java 的软肋，而是它在保持自身平台无关性的同时，灵活“借力”的一种表现

代码实现

注册和查找本地方法

扒拉了半天，道理我都懂，可是要从哪里开始啊，上面说的跟实现一点关系都没有。老样子，把自己当成JVM的设计师，在已知两种不同语言之间存在着相互调用，你会怎么做？

如果是两个不同语言之间互相调用，现在是Java调用C/C++，那么需要在JVM执行方法的时候识别并且注册本地方法。识别好说，本身就有native关键字。至于注册嘛！还是用Map结构，key就是方法签名，value就是具体的实现类。我们先定义一个接口，任何本地方法都必须实现这个接口。JNativeFunction代码如下：

/** * 执行本地方法接口 * * @author hqd */@FunctionalInterfacepublicinterfaceJNativeFunction{/** * 执行本地方法 * * @param jThread */voidinvoke(JThreadjThread);}

这个接口到时候肯定有很多实现，可不能自己一个个去new。多实现->策略->工厂。现在看到策略或者多实现，第一反应就是搭配工厂，用起来方便，省的一一去找，别人还得知道你有哪些实现。不过单纯的工厂不足以创建出来对应的本地方法实现，还不知道根据什么来创建，这里就取个巧，通过包名来。本地方法实现的包目录如下：

我们只需要获取本地方法所在类使用的包名，获取最后一个路径就能匹配上了。JNativeRegistryFactory代码如下：

/** * @author hqd */publicclassJNativeRegistryFactory{publicstaticJNativeFunctiongetInstance(JMethodjMethod){StringclassPath=jMethod.getJClass().getClassName();/** * 获取简单类名 */StringsimpleName=classPath.substring(classPath.lastIndexOf("/")+1);classPath=classPath.substring(0,classPath.lastIndexOf("/"));/** * 获取包名 */StringpackagePath=classPath.substring(classPath.lastIndexOf("/")+1);JNativeFunctionfunction=null;try{StringpackageName="com.hqd.jjvm.jnative."+packagePath+".";Class<JNativeRegistry>instanceClazz=(Class<JNativeRegistry>)Class.forName(packageName+"J"+simpleName+"NativeRegistry");instanceClazz.getConstructor().newInstance();function=JNativeRegistry.getJNativeFunction(jMethod);}catch(Exceptione){thrownewRuntimeException("get native function error："+e.getMessage());}returnfunction;}}

而后在定义一个注册器，方便管理本地方法。JNativeRegistry代码如下：

/** * 注册本地方法 * @author hqd */publicclassJNativeRegistry{publicstaticfinalMap<String,JNativeFunction>JNATIVE_METHOD_MAP=newConcurrentHashMap<>();protectedstaticvoidregisterNatives(JThreadjThread){/** * TODO 啥也不干 */}publicstaticvoidregistry(JMethodmethod,JNativeFunctionfunction){registry(method.getJClass().getClassName(),method.getName(),method.getDescriptor(),function);}publicstaticJNativeFunctiongetJNativeFunction(JMethodmethod){Stringname=method.getJClass().getClassName()+"."+method.getName()+"."+method.getDescriptor();returnJNATIVE_METHOD_MAP.get(name);}}

调用本地方法

那JVM在找到本地方法后，要怎么进行调用呢？既然是C/C++意味着没有方法体，不存在任何字节码。Java虚拟机规范也没有规定如何实现和调用本地方法，没规定？那就意味着可以随意发挥，可以充分的空间来发挥自己的想象力。于是，我们盯上了Java虚拟机规范预留了两条指令：

本地方法不是没有指令吗？那我们就给他指令。方法调用不是就是压栈吗？那就在压栈的时候插入我们自己的指令。我们先来实现指令。ReserveInstruction代码如下：

/** * @author hqd */publicclassReserveInstructionextendsAbstractInstruction{publicReserveInstruction(JThreadjThread){super(jThread);}@Overridepublicvoidexecute(InstructionTypeinstructionType){JMethodjMethod=getJMethod();JThreadjThread=getJThread();switch(instructionType){caseBREAKPOINT:{break;}caseIMPDEP1:{JNativeFunctionjNativeFunction=JNativeRegistryFactory.getInstance(jMethod);jNativeFunction.invoke(jThread);break;}caseIMPDEP2:{break;}}}}

再来先把之前的hack删掉，我们不需要他了。RefInstruction新增createNativeFrame方法，代码如下：

/** * 创建本地方法栈帧 * @param jThread * @param jMethod */privatevoidcreateNativeFrame(JThreadjThread,JMethodjMethod){jMethod.setMaxLocals(jMethod.getArgSlotCount());jMethod.setMaxStack(4);//创建指令StringBuildercode=newStringBuilder("FE");ClassUtil.getClassByDescriptor(jMethod.getDescriptor());switch(jMethod.getDescriptor().charAt(jMethod.getDescriptor().length()-1)){case'V':{// returncode.append("B1");break;}case'D':{// dreturncode.append("AF");break;}case'F':{// freturncode.append("AE");break;}case'J':{// lreturncode.append("AD");break;}case'C':case'S':case'B':case'Z':case'I':{// ireturncode.append("AC");break;}default:{// areturncode.append("B0");break;}}jMethod.setCode(newInstructionCode(code.toString()));jThread.createStackFrame(jMethod);}

而后，在把之前创建本地方法栈帧的TODO替换成对应方法：

实现本地方法

好了，准备工作已经做好了，接下来可以实现本地方法了。由于本地方法众多，这里就不一一展开说明。这里就是Object本地方法为例。我们使用的是Java语言，实现基本调用原本方法就行了。嘿嘿。JObjectNativeRegistry代码如下：

publicclassJObjectNativeRegistryextendsJNativeRegistry{privatestaticfinalJObjectNativeRegistryinstance=newJObjectNativeRegistry();protectedstaticfinalStringCLASS_PATH="java/lang/Object";static{registry(CLASS_PATH,"registerNatives","()V",JNativeRegistry::registerNatives);registry(CLASS_PATH,"hashCode","()I",JObjectNativeRegistry::hashCode0);registry(CLASS_PATH,"getClass","()Ljava/lang/Class;",JObjectNativeRegistry::getClass0);registry(CLASS_PATH,"clone","()Ljava/lang/Object;",JObjectNativeRegistry::clone0);registry(CLASS_PATH,"notifyAll","()V",JObjectNativeRegistry::notifyAll0);}privatestaticvoidnotifyAll0(JThreadjThread){}privatestaticvoidclone0(JThreadjThread){JObjectjObject=jThread.getJvmStack().getLocalVarsRefVal(0);try{JClassjc=jObject.getJClass().getLoader().loadJClass(Cloneable.class.getName());if(JClass.isImplements(jObject.getJClass(),jc)){thrownewCloneNotSupportedException(jObject.getJClass().getClassName()+" is not implements "+jc.getClassName());}jThread.getJvmStack().pushOperandStackRefVal(jObject.clone());}catch(Exceptione){thrownewRuntimeException("invoke clone0 error："+e.getMessage());}}privatestaticvoidgetClass0(JThreadjThread){JObjectthisObj=jThread.getJvmStack().getTop().getLocalVars().getRefVal(0);jThread.getJvmStack().getTop().pushRef(thisObj.getJClass().getJObject());}protectedstaticvoidhashCode0(JThreadjThread){inthashCode=jThread.getJvmStack().getLocalVarsRefVal(0).getData().hashCode();jThread.getJvmStack().pushOperandStackIntVal(hashCode);}publicstaticJObjectNativeRegistrygetInstance(){returninstance;}}

初始化基础类型

现在我们已经可以处理本地方法了，其中难免遇到一些基础类型，还需要对基础类型进行加载。修改JClassLoader#initLoad()方法，使其加载基础类型，代码如下：

protectedvoidinitLoad(){try{JClassjClass=this.loadJClass(Class.class.getName());jClass.setJObject(JMethodArea.getJClass(Class.class.getName()).newJObject());jClass=this.loadJClass(Object.class.getName());jClass.setJObject(JMethodArea.getJClass(Class.class.getName()).newJObject());this.loadJClass(String.class.getName());loadPrimitiveClass("float");loadPrimitiveClass("int");loadPrimitiveClass("double");loadPrimitiveClass("long");loadPrimitiveClass("byte");loadPrimitiveClass("boolean");loadPrimitiveClass("char");loadPrimitiveClass("short");}catch(ClassNotFoundExceptione){thrownewRuntimeException(e);}}privateJClassloadPrimitiveClass(StringclassName){JClassjClass=newJClass();jClass.setAccessFlags(CommonAccessFlag.ACC_PUBLIC.getHex());jClass.setLoader(this);jClass.setState(JClassState.FULLY_INITIALIZED);jClass.setClassName(className);bindingJClassObj(jClass);JMethodArea.putJClass(jClass);returnJMethodArea.getJClass(className);}

测试

ok，今天的任务也完成了。接下来进入测试环节。定义StringTest类，代码如下：

publicclassStringTest{publicstaticvoidmain(String[]args){Strings1="abc1";Strings2="abc1";System.out.println(s1==s2);// trueintx=1;Strings3="abc"+x;System.out.println(s1==s3);// falses3=s3.intern();System.out.println(s1==s3);// true}}

再添加一个测试入口类，NativeTest代码如下：

publicclassNativeTest{publicstaticvoidmain(String[]args){CmdCommandcmdCommand=newCmdCommand();cmdCommand.parseCmd(args);}}

idea添加如下配置：

-Xjre"D:\Oracle\Java\jdk1.8.0_281\jre"-cp"Z:\code\jjvm\ch09\target\test-classes"com.hqd.jjvm.jnative.StringTest

测试结果如下：

两个运行结果一直，说明我们字符串池没有问题

总结

今天主要讲述本地方法调用，整个JVM的实现进度已经开始倒计时了。。。