Java中的魔法类:sun.misc.Unsafe示例详解
前言
Unsafe类在jdk源码的多个类中用到,这个类的提供了一些绕开JVM的更底层功能,基于它的实现可以提高效率。但是,它是一把双刃剑:正如它的名字所预示的那样,它是Unsafe的,它所分配的内存需要手动free(不被GC回收)。Unsafe类,提供了JNI某些功能的简单替代:确保高效性的同时,使事情变得更简单。
这个类是属于sun.*API中的类,并且它不是J2SE中真正的一部份,因此你可能找不到任何的官方文档,更可悲的是,它也没有比较好的代码文档。
这篇文章主要是以下文章的整理、翻译。
http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/
1.UnsafeAPI的大部分方法都是native实现,它由105个方法组成,主要包括以下几类:
(1)Info相关。主要返回某些低级别的内存信息:addressSize(),pageSize()
(2)Objects相关。主要提供Object和它的域操纵方法:allocateInstance(),objectFieldOffset()
(3)Class相关。主要提供Class和它的静态域操纵方法:staticFieldOffset(),defineClass(),defineAnonymousClass(),ensureClassInitialized()
(4)Arrays相关。数组操纵方法:arrayBaseOffset(),arrayIndexScale()
(5)Synchronization相关。主要提供低级别同步原语(如基于CPU的CAS(Compare-And-Swap)原语):monitorEnter(),tryMonitorEnter(),monitorExit(),compareAndSwapInt(),putOrderedInt()
(6)Memory相关。直接内存访问方法(绕过JVM堆直接操纵本地内存):allocateMemory(),copyMemory(),freeMemory(),getAddress(),getInt(),putInt()
2.Unsafe类实例的获取
Unsafe类设计只提供给JVM信任的启动类加载器所使用,是一个典型的单例模式类。它的实例获取方法如下:
publicstaticUnsafegetUnsafe(){ Classcc=sun.reflect.Reflection.getCallerClass(2); if(cc.getClassLoader()!=null) thrownewSecurityException("Unsafe"); returntheUnsafe; }
非启动类加载器直接调用Unsafe.getUnsafe()方法会抛出SecurityException(具体原因涉及JVM类的双亲加载机制)。
解决办法有两个,其一是通过JVM参数-Xbootclasspath指定要使用的类为启动类,另外一个办法就是java反射了。
Fieldf=Unsafe.class.getDeclaredField("theUnsafe"); f.setAccessible(true); Unsafeunsafe=(Unsafe)f.get(null);
通过将private单例实例暴力设置accessible为true,然后通过Field的get方法,直接获取一个Object强制转换为Unsafe。在IDE中,这些方法会被标志为Error,可以通过以下设置解决:
Preferences->Java->Compiler->Errors/Warnings-> DeprecatedandrestrictedAPI->Forbiddenreference->Warning
3.Unsafe类“有趣”的应用场景
(1)绕过类初始化方法。当你想要绕过对象构造方法、安全检查器或者没有public的构造方法时,allocateInstance()方法变得非常有用。
classA{ privatelonga;//notinitializedvalue publicA(){ this.a=1;//initialization } publiclonga(){returnthis.a;} }
以下是构造方法、反射方法和allocateInstance()的对照
Ao1=newA();//constructor o1.a();//prints1 Ao2=A.class.newInstance();//reflection o2.a();//prints1 Ao3=(A)unsafe.allocateInstance(A.class);//unsafe o3.a();//prints0
allocateInstance()根本没有进入构造方法,在单例模式时,我们似乎看到了危机。
(2)内存修改
内存修改在c语言中是比较常见的,在Java中,可以用它绕过安全检查器。
考虑以下简单准入检查规则:
classGuard{ privateintACCESS_ALLOWED=1; publicbooleangiveAccess(){ return42==ACCESS_ALLOWED; } }
在正常情况下,giveAccess总会返回false,但事情不总是这样
Guardguard=newGuard(); guard.giveAccess();//false,noaccess //bypass Unsafeunsafe=getUnsafe(); Fieldf=guard.getClass().getDeclaredField("ACCESS_ALLOWED"); unsafe.putInt(guard,unsafe.objectFieldOffset(f),42);//memorycorruption guard.giveAccess();//true,accessgranted
通过计算内存偏移,并使用putInt()方法,类的ACCESS_ALLOWED被修改。在已知类结构的时候,数据的偏移总是可以计算出来(与c++中的类中数据的偏移计算是一致的)。
(3)实现类似C语言的sizeOf()函数
通过结合Java反射和objectFieldOffset()函数实现一个C-likesizeOf()函数。
publicstaticlongsizeOf(Objecto){ Unsafeu=getUnsafe(); HashSetfields=newHashSet(); Classc=o.getClass(); while(c!=Object.class){ for(Fieldf:c.getDeclaredFields()){ if((f.getModifiers()&Modifier.STATIC)==0){ fields.add(f); } } c=c.getSuperclass(); } //getoffset longmaxSize=0; for(Fieldf:fields){ longoffset=u.objectFieldOffset(f); if(offset>maxSize){ maxSize=offset; } } return((maxSize/8)+1)*8;//padding }
算法的思路非常清晰:从底层子类开始,依次取出它自己和它的所有超类的非静态域,放置到一个HashSet中(重复的只计算一次,Java是单继承),然后使用objectFieldOffset()获得一个最大偏移,最后还考虑了对齐。
在32位的JVM中,可以通过读取class文件偏移为12的long来获取size。
publicstaticlongsizeOf(Objectobject){ returngetUnsafe().getAddress( normalize(getUnsafe().getInt(object,4L))+12L); }
其中normalize()函数是一个将有符号int转为无符号long的方法
privatestaticlongnormalize(intvalue){ if(value>=0)returnvalue; return(0L>>>32)&value; }
两个sizeOf()计算的类的尺寸是一致的。最标准的sizeOf()实现是使用java.lang.instrument,但是,它需要指定命令行参数-javaagent。
(4)实现Java浅复制
标准的浅复制方案是实现Cloneable接口或者自己实现的复制函数,它们都不是多用途的函数。通过结合sizeOf()方法,可以实现浅复制。
staticObjectshallowCopy(Objectobj){ longsize=sizeOf(obj); longstart=toAddress(obj); longaddress=getUnsafe().allocateMemory(size); getUnsafe().copyMemory(start,address,size); returnfromAddress(address); }
以下的toAddress()和fromAddress()分别将对象转换到它的地址以及相反操作。
staticlongtoAddress(Objectobj){ Object[]array=newObject[]{obj}; longbaseOffset=getUnsafe().arrayBaseOffset(Object[].class); returnnormalize(getUnsafe().getInt(array,baseOffset)); } staticObjectfromAddress(longaddress){ Object[]array=newObject[]{null}; longbaseOffset=getUnsafe().arrayBaseOffset(Object[].class); getUnsafe().putLong(array,baseOffset,address); returnarray[0]; }
以上的浅复制函数可以应用于任意java对象,它的尺寸是动态计算的。
(5)消去内存中的密码
密码字段存储在String中,但是,String的回收是受到JVM管理的。最安全的做法是,在密码字段使用完之后,将它的值覆盖。
FieldstringValue=String.class.getDeclaredField("value"); stringValue.setAccessible(true); char[]mem=(char[])stringValue.get(password); for(inti=0;i(6)动态加载类
标准的动态加载类的方法是Class.forName()(在编写jdbc程序时,记忆深刻),使用Unsafe也可以动态加载java的class文件。
byte[]classContents=getClassContent(); Classc=getUnsafe().defineClass( null,classContents,0,classContents.length); c.getMethod("a").invoke(c.newInstance(),null);//1 getClassContent()方法,将一个class文件,读取到一个byte数组。 privatestaticbyte[]getClassContent()throwsException{ Filef=newFile("/home/mishadoff/tmp/A.class"); FileInputStreaminput=newFileInputStream(f); byte[]content=newbyte[(int)f.length()]; input.read(content); input.close(); returncontent; }动态加载、代理、切片等功能中可以应用。
(7)包装受检异常为运行时异常。
getUnsafe().throwException(newIOException());当你不希望捕获受检异常时,可以这样做(并不推荐)。
(8)快速序列化
标准的javaSerializable速度很慢,它还限制类必须有public无参构造函数。Externalizable好些,它需要为要序列化的类指定模式。流行的高效序列化库,比如kryo依赖于第三方库,会增加内存的消耗。可以通过getInt(),getLong(),getObject()等方法获取类中的域的实际值,将类名称等信息一起持久化到文件。kryo有使用Unsafe的尝试,但是没有具体的性能提升的数据。(http://code.google.com/p/kryo/issues/detail?id=75)
(9)在非Java堆中分配内存
使用java的new会在堆中为对象分配内存,并且对象的生命周期内,会被JVMGC管理。
classSuperArray{ privatefinalstaticintBYTE=1; privatelongsize; privatelongaddress; publicSuperArray(longsize){ this.size=size; address=getUnsafe().allocateMemory(size*BYTE); } publicvoidset(longi,bytevalue){ getUnsafe().putByte(address+i*BYTE,value); } publicintget(longidx){ returngetUnsafe().getByte(address+idx*BYTE); } publiclongsize(){ returnsize; } }Unsafe分配的内存,不受Integer.MAX_VALUE的限制,并且分配在非堆内存,使用它时,需要非常谨慎:忘记手动回收时,会产生内存泄露;非法的地址访问时,会导致JVM崩溃。在需要分配大的连续区域、实时编程(不能容忍JVM延迟)时,可以使用它。java.nio使用这一技术。
(10)Java并发中的应用
通过使用Unsafe.compareAndSwap()可以用来实现高效的无锁数据结构。
classCASCounterimplementsCounter{ privatevolatilelongcounter=0; privateUnsafeunsafe; privatelongoffset; publicCASCounter()throwsException{ unsafe=getUnsafe(); offset=unsafe.objectFieldOffset(CASCounter.class.getDeclaredField("counter")); } @Override publicvoidincrement(){ longbefore=counter; while(!unsafe.compareAndSwapLong(this,offset,before,before+1)){ before=counter; } } @Override publiclonggetCounter(){ returncounter; } }通过测试,以上数据结构与java的原子变量的效率基本一致,Java原子变量也使用Unsafe的compareAndSwap()方法,而这个方法最终会对应到cpu的对应原语,因此,它的效率非常高。这里有一个实现无锁HashMap的方案(http://www.azulsystems.com/about_us/presentations/lock-free-hash,这个方案的思路是:分析各个状态,创建拷贝,修改拷贝,使用CAS原语,自旋锁),在普通的服务器机器(核心<32),使用ConcurrentHashMap(JDK8以前,默认16路分离锁实现,JDK8中ConcurrentHashMap已经使用无锁实现)明显已经够用。
总结
以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对毛票票的支持。