Java sun.misc.unsafe类

ゝ一纸荒年。 2021-12-09 15:17 280阅读 0赞

Java是一个安全的开发工具，它阻止开发人员犯很多低级的错误，而大部份的错误都是基于内存管理方面的。如果你想搞破坏，可以使用Unsafe这个类。这个类是属于sun.\*API中的类，并且它不是J2SE中真正的一部份，因此你可能找不到任何的官方文档，更可悲的是，它也没有比较好的代码文档。

## 1、实例化sun.misc.Unsafe ##

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

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

2）、虽然它有静态的getUnsafe()方法，但是如果你尝试调用Unsafe.getUnsafe()，会得到一个SecutiryException。这个类只有被JDK信任的类实例化。但是这总会是有变通的解决办法的，一个简单的方式就是使用反射进行实例化：

1     Field f = Unsafe.class.getDeclaredField("theUnsafe"); //Internal reference  
    2     f.setAccessible(true);  
    3     Unsafe unsafe = (Unsafe) f.get(null);

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

（还有一种解决方法，就是将Eclipse中这种限制由错误，修改为警告，具体操作为将Windows->Preference...->Java->Compiler->Errors/Warnings中的"DeprecatedandrestrictedAPI"，级别由Error修改为Warning就可以了）

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

## 2、使用sun.misc.Unsafe ##

2.1、突破限制创建实例

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1     public class UnsafeDemo {  
     2         public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException {  
     3             Field f = Unsafe.class.getDeclaredField("theUnsafe"); // Internal reference  
     4             f.setAccessible(true);  
     5             Unsafe unsafe = (Unsafe) f.get(null);  
     6       
     7             // This creates an instance of player class without any initialization  
     8             Player p = (Player) unsafe.allocateInstance(Player.class);  
     9             System.out.println(p.getAge()); // Print 0  
    10       
    11             p.setAge(45); // Let's now set age 45 to un-initialized object  
    12             System.out.println(p.getAge()); // Print 45  
    13         }  
    14     }  
    15       
    16     class Player {  
    17         private int age = 12;  
    18       
    19         private Player() {  
    20             this.age = 50;  
    21         }  
    22       
    23         public int getAge() {  
    24             return this.age;  
    25         }  
    26       
    27         public void setAge(int age) {  
    28             this.age = age;  
    29         }  
    30     }

2.2、直接申请、操作物理内存（Java中Bits.byteOrder()就用了此法）

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1         Field f = Unsafe.class.getDeclaredField("theUnsafe"); // Internal reference
     2         f.setAccessible(true);
     3         Unsafe unsafe = (Unsafe) f.get(null);
     4         long a = unsafe.allocateMemory(8);
     5         System.out.printf("0x%2X 0x%2X\n", a, (a + 1));
     6         try {    
     7             unsafe.putLong(a, 0x0102030405060708L);
     8             byte b = unsafe.getByte(a);
     9             System.out.println(b);
    10 
    11         } finally {
    12             unsafe.freeMemory(a);
    13         }

2.3、常量Integer.MAX\_VALUE是JAVA中数组长度的最大值，如果想创建一个非常大的数组（虽然在通常的应用中不可能会用上，且可能会导致JVM挂掉），可以通过对内存进行直接分配实现。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 // 虽然可分批的元素个数（Long.MAX_VALUE）比Java本身的（Integer.MAX_VALUE）大，但可能会导致JVM挂掉。
     2 class SuperArray {
     3     Unsafe unsafe;
     4     private long address;// 字节数组起始地址
     5     private byte byteLenOfElementType;// 一个元素所占字节数
     6     private long size;// 元素个数
     7 
     8     /**
     9      * 初始化一个大数组
    10      * 
    11      * @param elemet_num
    12      *            元素的个数
    13      * @param bytes_of_element_type
    14      *            每个元素占用的字节数
    15      */
    16     public SuperArray(Unsafe unsafe, long elemet_num, byte bytes_of_element_type) {
    17         this.unsafe = unsafe;
    18         this.byteLenOfElementType = bytes_of_element_type;
    19         this.size = elemet_num;
    20 
    21         // 得到分配内存的起始地址
    22         this.address = unsafe.allocateMemory(size * byteLenOfElementType);
    23     }
    24 
    25     /**
    26      * 给数组某个元素赋值
    27      * 
    28      * @param index
    29      *            元素下标
    30      * @param value
    31      *            元素值
    32      */
    33     public void set(long index, byte[] value) {
    34         long startAddr = address + index * byteLenOfElementType;
    35         for (byte i = 0; i < byteLenOfElementType; i++) {
    36             unsafe.putByte(startAddr + i, value[i]);
    37         }
    38     }
    39 
    40     public byte[] get(long idx) {
    41         byte[] res = new byte[byteLenOfElementType];
    42         long startAddr = address + idx * byteLenOfElementType;
    43         for (byte i = 0; i < byteLenOfElementType; i++) {
    44             res[i] = unsafe.getByte(startAddr + i);
    45         }
    46         return res;
    47     }
    48 
    49     public long size() {
    50         return size;
    51     }
    52 }

## 3、参考资料 ##

1、[Java Magic. Part 4: sun.misc.Unsafe][Java Magic. Part 4_ sun.misc.Unsafe]

2、[http://blog.csdn.net/fenglibing/article/details/17138079][http_blog.csdn.net_fenglibing_article_details_17138079]

3、[https://blog.csdn.net/javazejian/article/details/72772470][https_blog.csdn.net_javazejian_article_details_72772470]（更多Unsafe相关）

转载于:https://www.cnblogs.com/z-sm/p/6724463.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211209/67bab8cab3ed43ed81a181aa08b64c66.png
[Java Magic. Part 4_ sun.misc.Unsafe]: http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/
[http_blog.csdn.net_fenglibing_article_details_17138079]: http://blog.csdn.net/fenglibing/article/details/17138079
[https_blog.csdn.net_javazejian_article_details_72772470]: https://blog.csdn.net/javazejian/article/details/72772470