sun.misc.Unsafe类详解

最新推荐文章于 2024-07-05 10:23:43 发布

强迫症Kobe

最新推荐文章于 2024-07-05 10:23:43 发布

阅读量1.1k

点赞数

分类专栏： java基础多线程，中断文章标签： java class Unsafe

java基础同时被 2 个专栏收录

50 篇文章 1 订阅

订阅专栏

多线程，中断

9 篇文章 0 订阅

订阅专栏

最近在看Java多线程的知识，在看到actomic类的时候发现了一个很少用到的类：unsafe。其实之前好像也见过相关的文章，但是当时没有留意，现在又碰上了，所以看了一些文章，汇总放在这里，以后多来看看。

sun.misc.unSafe包的下载地址放在最前面吧： http://download.csdn.net/detail/dfdsggdgg/9535347

如果你对技术有着不折不挠的追求，应该还会特别在意incrementAndGet() 方法中compareAndSet()的实现。现在，就让我们更进一步看一下它把！

[html]view plain copy 
   
 public final boolean compareAndSet(int expect, int update){  
     returnunsafe.compareAndSwapInt(this, valueOffset, expect, update);  
 }  

在这里，我们看到一个特殊的变量unsafe。它是sun.misc.Unsafe类型。从名字看，这个类应该是封装了一些不安全的操作。那什么操作是不安全的呢？学习过C或者C++的话，大家应该知道，指针是不安全的。这也是在Java中把指针去除的重要原因。如果指针指错了位置，或者计算指针偏移量时出错，结果可能是灾难性的，你很有可能会覆盖别人的内存，导致系统奔溃。

而这里的Unsafe就是封装了一些类似指针的操作。compareAndSwapInt()方法是一个navtive方法。它的几个参数含义如下：

[html]view plain copy 
   
 public final native boolean compareAndSwapInt(Object o,long offset,int expected,int x);  

第一个参数o为给定的对象，offset为对象内的偏移量（其实就是一个字段到对象头部的偏移量，通过这个偏移量可以快速定位字段），expected表示期望值，x表示要设置的值。如果指定的字段的值等于expected，那么就会把它设置为x。

不难看出，compareAndSwapInt()方法的内部，必然是使用CAS原子指令来完成的。此外，Unsafe类还提供了一些方法，主要有以下几个（以Int操作为例，其他数据类型是类似的）：

[java]view plain copy 
   
 //获得给定对象偏移量上的int值  
 public native int getInt(Object o, long offset);  
 //设置给定对象偏移量上的int值  
 public native void putInt(Object o, long offset, int x);  
 //获得字段在对象中的偏移量  
 public native long objectFieldOffset(Field f);  
 //设置给定对象的int值，使用volatile语义  
 public native void putIntVolatile(Object o, long offset,int x);  
 //获得给定对象对象的int值，使用volatile语义  
 public native int    getIntVolatile(Object o, long offset);  
 //和putIntVolatile()一样，但是它要求被操作字段就是volatile类型的  
 public native void putOrderedInt(Object o, long offset, intx);  

如果大家还记得“3.3.4 深度剖析ConcurrentLinkedQueue”一节中的描述的ConcurrentLinkedQueue实现，应该对ConcurrentLinkedQueue中的Node还有些印象。Node一些CAS操作也都是使用Unsafe类来实现的。大家可以回顾一下，以加深对Unsafe类的印象。

这里就可以看到，虽然Java抛弃了指针。但是在关键时刻，类似指针的技术还是必不可少的。这里底层的Unsafe实现就是最好的例子。但是很不幸，JDK的开发人员并不希望大家使用这个类。获得Unsafe实例的方法是调动其工厂方法getUnsafe()。但是，它的实现却是这样：

[java]view plain copy 
   
 public static Unsafe getUnsafe() {  
     Class cc =Reflection.getCallerClass();  
     if(cc.getClassLoader() != null)  
         throw newSecurityException("Unsafe");  
     return theUnsafe;  
 }  

注意加粗部分的代码，它会检查调用getUnsafe()函数的类，如果这个类的ClassLoader不为null，就直接抛出异常，拒绝工作。因此，这也使得我们自己的应用程序无法直接使用Unsafe类。它是一个JDK内部使用的专属类。

注意：根据Java 类加载器的工作原理，应用程序的类由AppLoader加载。而系统核心类，如rt.jar中的类由Bootstrap类加载器加载。Bootstrap加载器没有Java对象的对象，因此试图获得这个类加载器会返回null。所以，当一个类的类加载器为null时，说明它是由Bootstrap加载的，而这个类也极有可能是rt.jar中的类。

下面是一些这个类的特殊用法：真的很强大。

实例化sun.misc.Unsafe

如果你尝试创建Unsafe类的实例，基于以下两种原因是不被允许的。

1）、Unsafe类的构造函数是私有的；

2）、虽然它有静态的getUnsafe()方法，但是如果你尝试调用Unsafe.getUnsafe()，会得到一个SecutiryException。这个类只有被JDK信任的类实例化。

但是这总会是有变通的解决办法的，一个简单的方式就是使用反射进行实例化：

[java]view plain copy 
   
 Field f = Unsafe.class.getDeclaredField("theUnsafe"); //Internal reference  
 f.setAccessible(true);  
 Unsafe unsafe = (Unsafe) f.get(null);  

注：IDE如Eclipse对会这样的使用报错，不过不用担心，直接运行代码就行，可以正常运行的。

（译者注：还有一种解决方案，就是将Eclipse中这种限制获取由错误，修改为警告，具体操作为将Windows->Preference...->Java->Compiler->Errors/Warnings中的"Deprecated and restricted API"，级别由Error修改为Warning就可以了）

现在进入主题，使用这个对象我们可以做如下“有趣的”事情。

使用sun.misc.Unsafe

1）、突破限制创建实例

通过allocateInstance()方法，你可以创建一个类的实例，但是却不需要调用它的构造函数、初使化代码、各种JVM安全检查以及其它的一些底层的东西。即使构造函数是私有，我们也可以通过这个方法创建它的实例。

（这个对单例模式情有独钟的程序员来说将会是一个噩梦，它们没有办法阻止这种方式调用）

看下面一个实例（注：为了配合这个主题，译者将原实例中的public构造函数修改为了私有的）：

[java]view plain copy 
   
 public class UnsafeDemo {  
     public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException {  
         Field f = Unsafe.class.getDeclaredField("theUnsafe"); // Internal reference  
         f.setAccessible(true);  
         Unsafe unsafe = (Unsafe) f.get(null);  
   
         // This creates an instance of player class without any initialization  
         Player p = (Player) unsafe.allocateInstance(Player.class);  
         System.out.println(p.getAge()); // Print 0  
   
         p.setAge(45); // Let's now set age 45 to un-initialized object  
         System.out.println(p.getAge()); // Print 45  
     }  
 }  
   
 class Player {  
     private int age = 12;  
   
     private Player() {  
         this.age = 50;  
     }  
   
     public int getAge() {  
         return this.age;  
     }  
   
     public void setAge(int age) {  
         this.age = age;  
     }  
 }  

2）、使用直接获取内存的方式实现浅克隆

如何实现浅克隆？在clone(){...}方法中调用super.clone()，对吗？这里存在的问题是首先你必须继续Cloneable接口，并且在所有你需要做浅克隆的对象中实现clone()方法，对于一个懒懒的程序员来说，这个工作量太大了。

我不推荐上面的做法而是直接使用Unsafe，我们可以仅使用几行代码就实现浅克隆，并且它可以像某些工具类一样用于任意类的克隆。

这个戏法就是把一个对象的字节码拷贝到内存的另外一个地方，然后再将这个对象转换为被克隆的对象类型。

3）、来自黑客的密码安全

这个好似很有趣吧？实事就是这样的。开发人员创建密码或者是保证密码到字符串中，然后在应用程序的代码中使用这些密码，使用过后，聪明的程序员会把字符串的引用设为NULL，因此它就不会被引用着并且很容易被垃圾收集器给回收掉。

但是从你将引用设为NULL到被垃圾收集器收集的这个时间段之内（原文：But from the time, you made the reference null to the time garbage collector kicks in），它是处于字符串池中的，并且在你系统中进行一个复杂的攻击（原文：And a sophisticated attack on your system），也是可以读取到你的内存区域并且获得密码，虽然机会很小，但是总是存在的。

这就是为什么建议使用char[]数组存放密码，当使用完过后，你可以迭代处理当前数组，修改/清空这些字符。

另外一个方式就是使用魔术类Unsafe。你可以创建另外一个和当前密码字符串具有相同长度的临时字符串，将临时密码中的每个字符都设值为"?"或者"*"（任何字符都可以），当你完成密码的逻辑后，你只需要简单的将临时密码中的字节数组拷贝到原始的密码串中，这就是使用临时密码覆盖真实的密码。

示例代码可能会是这样：

[java]view plain copy 
   
 String password = new String("l00k@myHor$e");  
 String fake = new String(password.replaceAll(".", "?"));  
 System.out.println(password); // l00k@myHor$e  
 System.out.println(fake); // ????????????  
    
 getUnsafe().copyMemory(fake, 0L, null, toAddress(password), sizeOf(password));  
    
 System.out.println(password); // ????????????  
 System.out.println(fake); // ????????????  

运行时动态创建类

我们可以在运行时运态的创建类，例如通过编译后的.class文件，操作方式就是将.class文件读取到字节数据组中，并将其传到defineClass方法中。

[java]view plain copy 
   
 //Sample code to craeet classes  
 byte[] classContents = getClassContent();  
 Class c = getUnsafe().defineClass(null, classContents, 0, classContents.length);  
 c.getMethod("a").invoke(c.newInstance(), null);  
    
 //Method to read .class file  
 private static byte[] getClassContent() throws Exception {  
     File f = new File("/home/mishadoff/tmp/A.class");  
     FileInputStream input = new FileInputStream(f);  
     byte[] content = new byte[(int)f.length()];  
     input.read(content);  
     input.close();  
     return content;  
 }  

4）、超大数组

从所周知，常量Integer.MAX_VALUE是JAVA中数组长度的最大值，如果你想创建一个非常大的数组（虽然在通常的应用中不可能会用上），可以通过对内存进行直接分配实现。

下面这个示例将会创建分配一段连续的内存（数组），它的容易是允许最大容量的两倍。

[java]view plain copy 
   
 class SuperArray {  
     private final static int BYTE = 1;  
     private long size;  
     private long address;  
        
     public SuperArray(long size) {  
         this.size = size;  
         //得到分配内存的起始地址  
         address = getUnsafe().allocateMemory(size * BYTE);  
     }  
     public void set(long i, byte value) {  
         getUnsafe().putByte(address + i * BYTE, value);  
     }  
     public int get(long idx) {  
         return getUnsafe().getByte(address + idx * BYTE);  
     }  
     public long size() {  
         return size;  
     }  
 }  

应用示例

[java]view plain copy 
   
 long SUPER_SIZE = (long)Integer.MAX_VALUE * 2;  
 SuperArray array = new SuperArray(SUPER_SIZE);  
 System.out.println("Array size:" + array.size()); // 4294967294  
 for (int i = 0; i < 100; i++) {  
     array.set((long)Integer.MAX_VALUE + i, (byte)3);  
     sum += array.get((long)Integer.MAX_VALUE + i);  
 }  
 System.out.println("Sum of 100 elements:" + sum);  // 300  

但请注意这可能会导致JVM挂掉。

sun.misc.Unsafe提供了可以随意查看及修改JVM中运行时的数据结构，尽管这些功能在JAVA开发本身是不适用的，Unsafe是一个用于研究学习HotSpot虚拟机非常棒的工具，因为它不需要调用C++代码，或者需要创建即时分析的工具。

强迫症Kobe

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
sun.misc.Unsafe类详解

最近在看Java多线程的知识，在看到IntegerAtomic的时候发现了一个很少用到的类：unsafe。其实之前好像也见过相关的文章，但是当时没有留意，现在又碰上了，所以看了一些文章，汇总放在这里，以后多来看看。sun.misc.unSafe包的下载地址放在最前面吧： http://download.csdn.net/detail/dfdsggdgg/9535347如
复制链接

扫一扫

专栏目录