1、用什么操作内存？
sun.misc.Unsafe 这个类来操作，这个jdk自带的
2、怎么用呢？
如果我们打开这个Unsafe类，你很可能会这样获取，
Unsafe unsafe = Unsafe.getUnsafe();但是这样获取不到的，因为这个方法是Caller敏感的，看代码
@CallerSensitive
public static Unsafe getUnsafe() {
Class var0 = Reflection.getCallerClass();
if (var0.getClassLoader() != null) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}从代码中我们发现，只有当前调用这个getUnsafe（）方法的类的ClassLoader==null 才可以正常使用，ClassLoader==null意味着调用这个方法的类是jdk中C代码加载的，这里不赘述。
正确的使用方式：使用反射获取，看代码
public static Unsafe getUnsafe() {
final Object maybeUnsafe = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
try {
final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
Throwable cause = ReflectionUtil.trySetAccessible(unsafeField);
if (cause != null) {
return cause;
}
// the unsafe instance
return unsafeField.get(null);
} catch (NoSuchFieldException e) {
return e;
} catch (SecurityException e) {
return e;
} catch (IllegalAccessException e) {
return e;
}
}
});
return (Unsafe) maybeUnsafe;
}
3、使用Unsafe 操作成员变量
private class UnsafeObject {
private String fdStr;
private byte fd_byte;
private char fd_char;
private short fd_short;
private int fd_int;
private long fd_long;
private float fd_float;
private double fd_double;
private boolean fd_boolean;
}
@Test
public void test() throws NoSuchFieldException, InstantiationException {
Unsafe unsafe = getUnsafe();
UnsafeObject unSafeObject = new UnsafeObject();
// 获取fdStr偏移量
long fdStrOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fdStr"));
// 设置变量fdStr=fdStrValue
unsafe.putOrderedObject(unSafeObject, fdStrOffset, "fdStrValue");
// 根据对象和偏移量，获取变量fdStr的值
System.out.println("fdStr = " + unsafe.getObject(unSafeObject, fdStrOffset));
// unsafe.putObject();
long fd_byteOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_byte"));
unsafe.putByte(unSafeObject, fd_byteOffset, (byte) 32);
System.out.println("fd_byte = " + unsafe.getByte(unSafeObject, fd_byteOffset));
long fd_charOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_char"));
unsafe.putChar(unSafeObject, fd_charOffset, 'A');
System.out.println("fd_char = " + unsafe.getShort(unSafeObject, fd_charOffset));
long fd_shortOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_short"));
unsafe.putShort(unSafeObject, fd_shortOffset, (short) 5);
System.out.println("fd_short = " + unsafe.getShort(unSafeObject, fd_shortOffset));
long fd_intOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_int"));
unsafe.putInt(unSafeObject, fd_intOffset, 55555);
System.out.println("fd_int = " + unsafe.getInt(unSafeObject, fd_intOffset));
long fd_longOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_long"));
unsafe.putLong(unSafeObject, fd_longOffset, 12345678901234L);
System.out.println("fd_long = " + unsafe.getLong(unSafeObject, fd_longOffset));
long fd_floatOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_float"));
unsafe.putFloat(unSafeObject, fd_floatOffset, 1333333.5f);
System.out.println("fd_float = " + unsafe.getFloat(unSafeObject, fd_floatOffset));
long fd_doubleOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_double"));
unsafe.putDouble(unSafeObject, fd_doubleOffset, 52533566.555d);
System.out.println("fd_double = " + unsafe.getDouble(unSafeObject, fd_doubleOffset));
long fd_booleanOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_boolean"));
unsafe.putBoolean(unSafeObject, fd_booleanOffset, true);
System.out.println("fd_boolean = " + unsafe.getBoolean(unSafeObject, fd_booleanOffset));
}以上是unsfae.get*()和unsafe.put*() 等操作变量的方法,具体unsfae.get*Volatile(),unsfae.put*Volatile(),只不多是多Volatile语义，关于Volatile 具体可以查看
https://www.ibm.com/developerworks/cn/java/j-jtp06197.html
4、操作数组
@Test
public void test4() {
Unsafe unsafe = getUnsafe();
Class uoArrClass = UnsafeObject[].class;
// UnsafeObject[]数组基本偏移量
int uoBase = unsafe.arrayBaseOffset(uoArrClass);
// UnsafeObject[]数组单位偏移量，比如：数组[2]的偏移量=基本偏移量+2*单位偏移量
int uoIndexScale = unsafe.arrayIndexScale(uoArrClass);
System.out.println("uoBase = " + uoBase);
System.out.println("uoIndexScale = " + uoIndexScale);
int arrSize = 8;
int uoShift = 31 - Integer.numberOfLeadingZeros(uoIndexScale);
UnsafeObject[] uoArr = new UnsafeObject[arrSize];
int index = 3; // 数组索引
long u = (index << uoShift) + uoBase;// 偏移量
UnsafeObject unsafeObject = new UnsafeObject();
// System.out.println("unsafeObject = " + unsafeObject);
// 把数据存放到数组索引=3 中，相当于uoArr[3]=unsafeObject;compareAndSwapObject 是原子操作
unsafe.compareAndSwapObject(uoArr, u, null, unsafeObject);
Object object = unsafe.getObjectVolatile(uoArr, u);
Object object2 = uoArr[index];
// System.out.println("object = " + object);
// System.out.println("object2 = " + object2);
System.out.println("unsafeObject.equals(object) = " + unsafeObject.equals(object));
System.out.println("unsafeObject.equals(object2) = " + unsafeObject.equals(object2));
}如代码操作数组，非常高效，在jdk内部用的非常多，比如ConcurrentHashMap里就用到了
注：UnsafeObject这个类在第3点里
5、内存操作
@Test
public void test2() throws InterruptedException {
Unsafe unsafe = getUnsafe();
long size = 5;
long address = unsafe.allocateMemory(size); // 申请内存
System.out.println(address);
unsafe.setMemory(address, size, (byte) -1);// 设置内存
System.out.println(unsafe.getByte(address)); // 根据地址获取数据
for (int i = 0; i < size; i++) {
unsafe.putByte(address + i, (byte) i);
}
for (int i = 0; i < size; i++) {
System.out.println(unsafe.getByte(address + i));
}
unsafe.freeMemory(address); // 释放内存
}
6、使用场景
一般的话，讲究极致性能的，我们可以使用unsafe，比如netty就用到了。但是如果使用的话要兼容各个版本的jdk。在业务系统里，不建议使用，如果搞不到很可能导致内存泄露。
7、总结
这个类还没完全分析完，有待更新
为什么要写这个？
主要是在分析ConcurrentHashMap代码时遇到Unsafe，所以就想分析分析，为分析ConcurrentHashMap做准备。
如果想了解ConcurrentHashMap，请关注，后续持续更新。
代码地址：https://github.com/tingliu9/basic-test/blob/master/src/test/java/com/github/tingliu/basic/test/UnsafeTest.java
jdk版本：jdk7_75
如果不对，请赐教！
持续更新有意思的代码
转载于:https://my.oschina.net/huangy/blog/1620321