Unsafe类是java中非常特别的一个类。它名字就叫做“不安全”,提供的操作可以直接读写内存、获得地址偏移值、锁定或释放线程。

通过正常途径是无法获得Unsafe实例的,首先它的构造方法是私有的,然后,即使你调用它的getUnsafe方法,也会抛出SecurityException。

A collection of methods for performing low-level, unsafe operations. Although the class and all methods are public, use of this class islimited because only trusted code can obtain instances of it.

任何关于Unsafe类的文章都不会推荐我们在代码中使用它,但这并不妨碍我们了解它可以做什么。下面我们来看下利用Unsafe类我们是否可以做点有趣的事情。

##获取Unsafe实例

public static Unsafe getUnsafeInstance() throws Exception{
	Field unsafeStaticField = 
	Unsafe.class.getDeclaredField("theUnsafe");
	unsafeStaticField.setAccessible(true);
	return (Unsafe) unsafeStaticField.get(Unsafe.class);
}

通过java反射机制,我们跳过了安全检测,拿到了一个unsafe类的实例。

我找遍了Unsafe类的API,没有发现可以直接获取对象地址的方法,Unsafe中操作地址相关的方法都要求提供一个Object类型的参数,用来获取对象的初始地址。

##修改和读取数组中的值

Unsafe u = getUnsafeInstance();

int[] arr = {1,2,3,4,5,6,7,8,9,10};

int b = u.arrayBaseOffset(int[].class);

int s = u.arrayIndexScale(int[].class);

u.putInt(arr, (long)b+s*9, 1);

for(int i=0;i<10;i++){

	int v = u.getInt(arr, (long)b+s*i);

	System.out.print(v+ );

}

打印结果:1 2 3 4 5 6 7 8 9 1 ,可以看到,成功读出了数组中的值,而且最后一个值由10改为了1。

  • arrayBaseOffset: 返回当前数组第一个元素地址相对于数组起始地址的偏移值,在本例中返回6。

  • arrayIndexScale: 返回当前数组一个元素占用的字节数,在本例中返回4。

  • putInt(obj,offset,intval): 获取数组对象obj的起始地址,加上偏移值,得到对应元素的地址,将intval写入内存。

  • getInt(obj,offset): 获取数组对象obj的起始地址,加上偏移值,得到对应元素的地址,从而获得元素的值。

  • 偏移值: 数组元素偏移值 = arrayBaseOffset + arrayIndexScalse * i。

##获取对象实例

/** 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;

allocateInstance: 在不执行构造方法的前提下,获取一个类的实例,即使这个类的构造方法是私有的。

##修改静态变量和实例变量的值

先定义一个Test类

public class Test {
	
	public int intfield ;
	
	public static int staticIntField;
	
	public static int[] arr;
	
	private Test(){
		System.out.println("constructor called");
	}
}

修改Test类的实例变量

Unsafe u = getUnsafeInstance();

Test t = (Test) u.allocateInstance(Test.class);

long b1 = u.objectFieldOffset(Test.class.getDeclaredField("intfield"));

u.putInt(t, b1, 2);

System.out.println("intfield:"+t.intfield);

这里使用allocateInstance方法获取了一个Test类的实例,并且没有打印“constructor called”,说明构造方法没有调用。 修改实例变量与修改数组的值类似,同样要获取地址偏移值,然后调用putInt方法。

  • objectFieldOffset: 获取对象某个属性的地址偏移值。

我们通过Unsafe类修改了Java堆中的数据。

修改Test类的静态变量

Field staticIntField = Test.class.getDeclaredField("staticIntField");

Object o = u.staticFieldBase(staticIntField);

System.out.prinln(o==Test.class);

Long b4 = u.staticFieldOffset(staticIntField);
//因为是静态变量,传入的Object参数应为class对象
u.putInt(o, b4, 10);

System.out.println("staticIntField:"+u.getInt(Test.class, b4));	

打印结果:

true

staticIntField:10

静态变量与实例变量不同之处在于,静态变量位于于方法区中,它的地址偏移值与Test类在方法区的地址相关,与Test类的实例无关。

  • staticFieldBase: 获取静态变量所属的类在方法区的首地址。可以看到,返回的对象就是Test.class。

  • staticFieldOffset: 获取静态变量地址偏移值。

我们通过Unsafe类修改了方法区中的信息。

##调戏String.intern

在jdk7中,String.intern不再拷贝string对象实例,而是保存第一次出现的对象的引用。在下面的代码中,通过Unsafe修改被引用对象s的私有属性value达到间接修改s1的效果!

String s = "abc";

//保存s的引用
s.intern();

//此时s1==s,地址相同
String s1 = "abc";

Unsafe u = getUnsafeInstance();

//获取s的实例变量value
Field valueInString = String.class.getDeclaredField("value");

//获取value的变量偏移值
long offset = u.objectFieldOffset(valueInString);

//value本身是一个char[],要修改它元素的值,仍要获取baseOffset和indexScale
long base = u.arrayBaseOffset(char[].class);

long scale = u.arrayIndexScale(char[].class);

//获取value
char[] values = (char[]) u.getObject(s, offset);

//为value赋值
u.putChar(values, base + scale, 'c');

System.out.println("s:"+s+" s1:"+s1);

//将s的值改为 abc
s = "abc";

String s2 = "abc";

String s3 = "abc";

System.out.println("s:"+s+" s1:"+s1);

打印结果:

s:acc s1:acc

s:acc s1:acc s2:acc s3:acc

我们发现了什么?所有值为“abc”的字符串都变成了“acc”!!!

Unsafe类果然不安全!!!