前言

以下sun.misc.Unsafe源码和demo基于jdk1.7;

最近在看J.U.C里的源码,很多都用到了sun.misc.Unsafe这个类,一知半解,看起来总感觉有点不尽兴,所以打算对Unsafe的源码及使用做个分析;

另外,网上找了份c++的源代码natUnsafe.cc(可惜比较老,Copyright (C) 2006, 2007年的,没找到新的),也就是sun.misc.Unsafe的C++实现,跟Unsafe类中的native方法对照起来看更加容易理解;

Unsafe类的作用

可以用来在任意内存地址位置处读写数据,可见,对于普通用户来说,使用起来还是比较危险的;

另外,还支持一些CAS原子操作;

获取Unsafe对象

遗憾的是,Unsafe对象不能直接通过new Unsafe()或调用Unsafe.getUnsafe()获取,原因如下:

*不能直接new Unsafe(),原因是Unsafe被设计成单例模式,构造方法是私有的;

*不能通过调用Unsafe.getUnsafe()获取,因为getUnsafe被设计成只能从引导类加载器(bootstrap class loader)加载,从getUnsafe的源码中也可以看出来,如下:

    @CallerSensitive
public static Unsafe getUnsafe() {
//得到调用该方法的Class对象
Class cc = Reflection.getCallerClass();
//判断调用该方法的类是否是引导类加载器(bootstrap class loader)
//如果不是的话,比如由AppClassLoader调用该方法,则抛出SecurityException异常
if (cc.getClassLoader() != null)
throw new SecurityException("Unsafe");
//返回单例对象
return theUnsafe;
}

虽然我们不能通过以上方法得到Unsafe对象,但得Unsafe类中有个私有的静态全局属性theUnsafe(Unsafe实例对象),通过反射,可以获取到该成员属性theUnsafe对应的Field对象,并将其设置为可访问,从而得到theUnsafe具体对象,如下代码:

package concurrency;

import java.lang.reflect.Field;
import sun.misc.Unsafe;
import sun.reflect.Reflection; public class Test {
public static void main(String[] args) throws NoSuchFieldException,
SecurityException, IllegalArgumentException, IllegalAccessException {
// 通过反射得到theUnsafe对应的Field对象
Field field = Unsafe.class.getDeclaredField("theUnsafe");
// 设置该Field为可访问
field.setAccessible(true);
// 通过Field得到该Field对应的具体对象,传入null是因为该Field为static的
Unsafe unsafe = (Unsafe) field.get(null);
System.out.println(unsafe); }
}

Unsafe类中的API

allocateInstance方法,不调用构造方法生成对象

本地方法,功能是生成一个对象实例,但是不会运行该对象的构造方法;由于natUnsafe.cc版本较老,没找到对应的c++实现;

    /** Allocate an instance but do not run any constructor. Initializes the class if it has not yet been. */
public native Object allocateInstance(Class cls)
throws InstantiationException;

例子,利用Unsafe的allocateInstance方法,在未调用构造方法的情况下生成了对象:

package concurrency;

import java.lang.reflect.Field;

import sun.misc.Unsafe;
import sun.reflect.Reflection; class User {
private String name = "";
private int age = 0; public User() {
this.name = "test";
this.age = 22;
} @Override
public String toString() {
return name + ": " + age;
}
} public class Test {
public static void main(String[] args) throws NoSuchFieldException,
SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException {
// 通过反射得到theUnsafe对应的Field对象
Field field = Unsafe.class.getDeclaredField("theUnsafe");
// 设置该Field为可访问
field.setAccessible(true);
// 通过Field得到该Field对应的具体对象,传入null是因为该Field为static的
Unsafe unsafe = (Unsafe) field.get(null); User user = (User) unsafe.allocateInstance(User.class);
System.out.println(user); //dont invoke constructor, print null: 0 User userFromNormal = new User();
System.out.println(userFromNormal); //print test: 22 }
}

objectFieldOffset方法,返回成员属性在内存中的地址相对于对象内存地址的偏移量

比较简单,就是返回成员属性内存地址相对于对象内存地址的偏移量,通过该方法可以计算一个对象在内存中的空间大小,方法是通过反射得到它的所有Field(包括父类继承得到的),找出Field中偏移量最大值,然后对该最大偏移值填充字节数即为对象大小;

关于该方法的使用例子可以看下面的修改内存数据的例子;

putLong,putInt,putDouble,putChar,putObject等方法,直接修改内存数据(可以越过访问权限)

这里,还有put对应的get方法,很简单就是直接读取内存地址处的数据,不做举例;

我们可以举个putLong(Object, long, long)方法详细看下其具体实现,其它的类似,先看Java的源码,没啥好看的,就声明了一个native本地方法:

三个参数说明下:

Object o//对象引用
long offset//对象内存地址的偏移量
long x//写入的数据
    public native void    putLong(Object o, long offset, long x);

还是看下natUnsafe.cc中的c++实现吧,很简单,就是计算要写入数据的内存地址,然后写入数据,如下:

void
sun::misc::Unsafe::putLong (jobject obj, jlong offset, jlong value)
{
jlong *addr = (jlong *) ((char *) obj + offset);//计算要修改的数据的内存地址=对象地址+成员属性地址偏移量
spinlock lock;//自旋锁,通过循环来获取锁, i386处理器需要加锁访问64位数据,如果是int,则不需要改行代码
*addr = value;//往该内存地址位置直接写入数据
}

如下例子,即使User类的成员属性是私有的且没有提供对外的public方法,我们还是可以直接在它们的内存地址位置处写入数据,并成功;

package concurrency;

import java.lang.reflect.Field;

import sun.misc.Unsafe;
import sun.reflect.Reflection; class User {
private String name = "test";
private long id = 1;
private int age = 2;
private double height = 1.72; @Override
public String toString() {
return name + "," + id + "," + age + "," + height;
}
} public class Test {
public static void main(String[] args) throws NoSuchFieldException,
SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException {
// 通过反射得到theUnsafe对应的Field对象
Field field = Unsafe.class.getDeclaredField("theUnsafe");
// 设置该Field为可访问
field.setAccessible(true);
// 通过Field得到该Field对应的具体对象,传入null是因为该Field为static的
Unsafe unsafe = (Unsafe) field.get(null); User user = new User();
System.out.println(user); //打印test,1,2,1.72 Class userClass = user.getClass();
Field name = userClass.getDeclaredField("name");
Field id = userClass.getDeclaredField("id");
Field age = userClass.getDeclaredField("age");
Field height = userClass.getDeclaredField("height");
//直接往内存地址写数据
unsafe.putObject(user, unsafe.objectFieldOffset(name), "midified-name");
unsafe.putLong(user, unsafe.objectFieldOffset(id),100l);
unsafe.putInt(user, unsafe.objectFieldOffset(age), 101);
unsafe.putDouble(user, unsafe.objectFieldOffset(height), 100.1); System.out.println(user);//打印midified-name,100,101,100.1 }
}

copyMemory、freeMemory

copyMemory:内存数据拷贝

freeMemory:用于释放allocateMemory和reallocateMemory申请的内存

CAS操作的方法,compareAndSwapInt,compareAndSwapLong等

看下natUnsafe.cc中的c++实现吧,加深理解,其实就是将内存值与预期值作比较,判断是否相等,相等的话,写入数据,不相等不做操作,返回旧数据;

static inline bool
compareAndSwap (volatile jint *addr, jint old, jint new_val)
{
jboolean result = false;
spinlock lock;
if ((result = (*addr == old)))
*addr = new_val;
return result;
}

J.U.C里原子类就是基于以上CAS操作实现的;

getLongVolatile/putLongVolatile等等方法

这类方法使用volatile语义去存取数据,我的理解就是各个线程不缓存数据,直接在内存中读取数据;

参考连接:

https://github.com/aeste/gcc/blob/master/libjava/sun/misc/natUnsafe.cc

http://ifeve.com/sun-misc-unsafe/

http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/sun/misc/Unsafe.java

-------------------------------------------------------------------------------------------------------------------------------------------

下面是一篇转载补充:

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

实例化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中的"Deprecated and restricted API",级别由Error修改为Warning就可以了)

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

使用sun.misc.Unsafe

1)、突破限制创建实例

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

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

看下面一个实例(注:为了配合这个主题,译者将原实例中的public构造函数修改为了私有的):

  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. // This creates an instance of player class without any initialization
  7. Player p = (Player) unsafe.allocateInstance(Player.class);
  8. System.out.println(p.getAge()); // Print 0
  9. p.setAge(45); // Let's now set age 45 to un-initialized object
  10. System.out.println(p.getAge()); // Print 45
  11. }
  12. }
  13. class Player {
  14. private int age = 12;
  15. private Player() {
  16. this.age = 50;
  17. }
  18. public int getAge() {
  19. return this.age;
  20. }
  21. public void setAge(int age) {
  22. this.age = age;
  23. }
  24. }

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。你可以创建另外一个和当前密码字符串具有相同长度的临时字符串,将临时密码中的每个字符都设值为"?"或者"*"(任何字符都可以),当你完成密码的逻辑后,你只需要简单的将临时密码中的字节数组拷贝到原始的密码串中,这就是使用临时密码覆盖真实的密码。

示例代码可能会是这样:

  1. String password = new String("l00k@myHor$e");
  2. String fake = new String(password.replaceAll(".", "?"));
  3. System.out.println(password); // l00k@myHor$e
  4. System.out.println(fake); // ????????????
  5. getUnsafe().copyMemory(fake, 0L, null, toAddress(password), sizeOf(password));
  6. System.out.println(password); // ????????????
  7. System.out.println(fake); // ????????????

运行时动态创建类

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

  1. //Sample code to craeet classes
  2. byte[] classContents = getClassContent();
  3. Class c = getUnsafe().defineClass(null, classContents, 0, classContents.length);
  4. c.getMethod("a").invoke(c.newInstance(), null);
  5. //Method to read .class file
  6. private static byte[] getClassContent() throws Exception {
  7. File f = new File("/home/mishadoff/tmp/A.class");
  8. FileInputStream input = new FileInputStream(f);
  9. byte[] content = new byte[(int)f.length()];
  10. input.read(content);
  11. input.close();
  12. return content;
  13. }

4)、超大数组

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

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

  1. class SuperArray {
  2. private final static int BYTE = 1;
  3. private long size;
  4. private long address;
  5. public SuperArray(long size) {
  6. this.size = size;
  7. //得到分配内存的起始地址
  8. address = getUnsafe().allocateMemory(size * BYTE);
  9. }
  10. public void set(long i, byte value) {
  11. getUnsafe().putByte(address + i * BYTE, value);
  12. }
  13. public int get(long idx) {
  14. return getUnsafe().getByte(address + idx * BYTE);
  15. }
  16. public long size() {
  17. return size;
  18. }
  19. }

应用示例

  1. long SUPER_SIZE = (long)Integer.MAX_VALUE * 2;
  2. SuperArray array = new SuperArray(SUPER_SIZE);
  3. System.out.println("Array size:" + array.size()); // 4294967294
  4. for (int i = 0; i < 100; i++) {
  5. array.set((long)Integer.MAX_VALUE + i, (byte)3);
  6. sum += array.get((long)Integer.MAX_VALUE + i);
  7. }
  8. System.out.println("Sum of 100 elements:" + sum);  // 300

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

结束语

sun.misc.Unsafe provides almost unlimited capabilities for exploring and modification of VM’s runtime data structures. Despite the fact that these capabilities are almost inapplicable in Javadevelopment itself, Unsafe is a great tool for anyone who want to study HotSpot VM without C++ code debugging or need to create ad hoc profiling instruments.

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

参考

http://mishadoff.github.io/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/

Java的sun.misc.Unsafe类的更多相关文章

  1. JDK 1.8 sun.misc.Unsafe类CAS底层实现

    在java.util.concurrent包下面的很多类为了追求性能都采用了sun.misc.Unsafe类中的CAS操作,从而避免使用synchronized等加锁方式带来性能上的不足. 在sun. ...

  2. Java sun.misc.Unsafe类的学习笔记

    Java未开源的Unsafe类 Unsafe类可以为我们提供高效并且线程安全方式操作变量,直接和内存数据打交道. 获取Unsafe实体的方法 private static Unsafe getUnsa ...

  3. Java sun.misc.unsafe类

    Java是一个安全的开发工具,它阻止开发人员犯很多低级的错误,而大部份的错误都是基于内存管理方面的.如果你想搞破坏,可以使用Unsafe这个类.这个类是属于sun.*API中的类,并且它不是J2SE中 ...

  4. 并发编程之sun.misc.Unsafe类

    1.Unsafe知识点整理 2.代码: package com.javabasic.unsafe; import java.lang.reflect.Field; import sun.misc.Un ...

  5. [Java 基础]sun.misc.Unsafe

    使用Unsafe可以干一些好事. Unsafe对象初始化 如果你的代码属于trusted的,可以直接使用下面的方式: public static Unsafe getUnsafe() { Class ...

  6. sun.misc.unsafe类的使用

    http://blog.csdn.net/fenglibing/article/details/17138079

  7. eclipse无法访问sun.misc.Unsafe类的解决办法

    参考:https://www.cnblogs.com/duanxz/p/6090442.html

  8. java.util.concurrent各组件分析 一 sun.misc.Unsafe

    java.util.concurrent各组件分析 一 sun.misc.Unsafe 说到concurrent包也叫并发包,该包下主要是线程操作,方便的进行并发编程,提到并发那么锁自然是不可缺少的, ...

  9. sun.misc.Unsafe 详解

    原文地址 译者:许巧辉 校对:梁海舰 Java是一门安全的编程语言,防止程序员犯很多愚蠢的错误,它们大部分是基于内存管理的.但是,有一种方式可以有意的执行一些不安全.容易犯错的操作,那就是使用Unsa ...

随机推荐

  1. 如何在OS X 10.9 Mavericks下安装Command Line Tools(命令行工具)

    随着OS X 10.9 于 2013年6月10日在旧金山WWDC(world wide developer conference)上发布.是首个不使用猫科动物命名的系统,而转用加利福尼亚的产物. 该系 ...

  2. LeetCode题解 #8 String to Integer (atoi)

    又是一道恶心的简单题. 一开始没想到这么多情况的,幸好LeetCode是个很人性化的oj,能让你知道你在哪个case上错了,否则一辈子都过不了. 考虑不周到只能一个个补了. 列举一下恶心的case / ...

  3. Shiro 权限校验不通过时,区分GET和POST请求正确响应对应的方式

    引入:https://blog.csdn.net/catoop/article/details/69210140 本文基于Shiro权限注解方式来控制Controller方法是否能够访问. 例如使用到 ...

  4. 关于struts2.x中(警告: Could not find property [struts.valueStack])的解决方法

    出现“警告: Could not find property [struts.valueStack]”这样的问题,是由于少引用了log4j.jar包,不过,不引用也不影响使用.看个人的爱好了.

  5. Makefile里面打印信息

    Makefile的规则相对来说还是比较复杂的,上手不容易,没有系统研究过,往往搞不清楚状况.如果掌握了基本的调试手段,那对我们写出正确的Makefile会非常有帮助.而在Makefile中,最重要的调 ...

  6. CyclicBarrier的使用

    最近一直整并发这块东西,顺便写点Java并发的例子,给大家做个分享,也强化下自己记忆,如果有什么错误或者不当的地方,欢迎大家斧正. CyclicBarrier是一种多线程并发控制实用工具,和Count ...

  7. Excel VBA入门(七)注释、宏按钮及错误处理

    系统性的知识前面已经讲完,从本章开始,本系列教程涉及的将会是一些相对凌散的内容. 1. 注释 代码注释是一件利人利己的事,为了方便自己在代码需要更新修改时,依然能够快速地看懂自己完的每一行代码到底是什 ...

  8. nginx 多域名配置,采用多配置文件的方式

    nginx 中多域名配置,目前采用多配置文件的方式. 配置过程比较简单. 首先在 nginx 目录下创建子目录 vhosts . 在 vhosts 目录中创建对应域名的配置文件.如有域名 898hi. ...

  9. ubuntu 源码安装 lnmp 环境

    准备篇 下载软件包 1.下载nginx http://nginx.org/download/nginx-1.2.0.tar.gz 2.下载pcre  (支持nginx伪静态) ftp://ftp.cs ...

  10. SpringBoot30 整合Mybatis-Plus、整合Redis、利用Ehcache实现二级缓存、利用SpringCache和Redis作为缓存

    1 环境说明 JDK: 1.8 MAVEN: 3. SpringBoot: 2.0.4 2 SpringBoot集成Mybatis-Plus 2.1 创建SpringBoot 利用IDEA创建Spri ...