Java多线程深入学习-Unsafe类的介绍

老规矩，直接源码--

/**
 * Unsafe类使Java拥有了像C语言的指针一样操作内存空间的能力，一旦能够直接操作内存，这也就意味着
 * （1）不受jvm管理，也就意味着无法被GC，需要我们手动GC，稍有不慎就会出现内存泄漏。
 * （2）Unsafe的不少方法中必须提供原始地址(内存地址)和被替换对象的地址，偏移量要自己计算，
 * 		一旦出现问题就是JVM崩溃级别的异常，会导致整个JVM实例崩溃，表现为应用程序直接crash掉。
 * （3）直接操作内存，也意味着其速度更快，在高并发的条件之下能够很好地提高效率
 */
public final class Unsafe {
	private static final Unsafe theUnsafe;
	public static final int INVALID_FIELD_OFFSET = -1;
	public static final int ARRAY_BOOLEAN_BASE_OFFSET;
	public static final int ARRAY_BYTE_BASE_OFFSET;
	public static final int ARRAY_SHORT_BASE_OFFSET;
	public static final int ARRAY_CHAR_BASE_OFFSET;
	public static final int ARRAY_INT_BASE_OFFSET;
	public static final int ARRAY_LONG_BASE_OFFSET;
	public static final int ARRAY_FLOAT_BASE_OFFSET;
	public static final int ARRAY_DOUBLE_BASE_OFFSET;
	public static final int ARRAY_OBJECT_BASE_OFFSET;
	public static final int ARRAY_BOOLEAN_INDEX_SCALE;
	public static final int ARRAY_BYTE_INDEX_SCALE;
	public static final int ARRAY_SHORT_INDEX_SCALE;
	public static final int ARRAY_CHAR_INDEX_SCALE;
	public static final int ARRAY_INT_INDEX_SCALE;
	public static final int ARRAY_LONG_INDEX_SCALE;
	public static final int ARRAY_FLOAT_INDEX_SCALE;
	public static final int ARRAY_DOUBLE_INDEX_SCALE;
	public static final int ARRAY_OBJECT_INDEX_SCALE;
	public static final int ADDRESS_SIZE;

	/** 初始化方法 */
	@SuppressWarnings("rawtypes")
	@CallerSensitive
	public static Unsafe getUnsafe() {
		Class var0 = Reflection.getCallerClass();
		if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
			throw new SecurityException("Unsafe");
		} else {
			return theUnsafe;	//单例
		}
	}

	public native int getInt(Object var1, long var2);

	public native void putInt(Object var1, long var2, int var4);

	/**
	 * 通过给定的Java变量获取引用值。这里实际上是在var1中，获取偏移地址为var2的属性的值，
	 * 此方法可以突破修饰符的抑制，也就是无视private、protected和default修饰符。
	 */
	public native Object getObject(Object var1, long var2);
	public native boolean getBoolean(Object var1, long var2);
	public native byte getByte(Object var1, long var2);
	public native short getShort(Object var1, long var2);
	public native char getChar(Object var1, long var2);
	public native long getLong(Object var1, long var2);
	public native float getFloat(Object var1, long var2);
	public native double getDouble(Object var1, long var2);
	
	/**
	 * 设置var1对象中var2偏移地址对应的Object型field的值为指定值var4。
	 * 这是一个有序或者有延迟的putObjectVolatile方法，并且不保证值的改变被其他线程立即看到。
	 * 只有在field被volatile修饰并且期望被修改的时候使用才会生效
	 */
	public native void putObject(Object var1, long var2, Object var4);
	public native void putBoolean(Object var1, long var2, boolean var4);
	public native void putByte(Object var1, long var2, byte var4);
	public native void putShort(Object var1, long var2, short var4);
	public native void putChar(Object var1, long var2, char var4);
	public native void putLong(Object var1, long var2, long var4);
	public native void putFloat(Object var1, long var2, float var4);
	public native void putDouble(Object var1, long var2, double var4);
	@Deprecated
	public int getInt(Object var1, int var2) {
		return this.getInt(var1, (long) var2);
	}
	@Deprecated
	public void putInt(Object var1, int var2, int var3) {
		this.putInt(var1, (long) var2, var3);
	}
	@Deprecated
	public Object getObject(Object var1, int var2) {
		return this.getObject(var1, (long) var2);
	}
	@Deprecated
	public void putObject(Object var1, int var2, Object var3) {
		this.putObject(var1, (long) var2, var3);
	}
	@Deprecated
	public boolean getBoolean(Object var1, int var2) {
		return this.getBoolean(var1, (long) var2);
	}
	@Deprecated
	public void putBoolean(Object var1, int var2, boolean var3) {
		this.putBoolean(var1, (long) var2, var3);
	}
	@Deprecated
	public byte getByte(Object var1, int var2) {
		return this.getByte(var1, (long) var2);
	}
	@Deprecated
	public void putByte(Object var1, int var2, byte var3) {
		this.putByte(var1, (long) var2, var3);
	}
	@Deprecated
	public short getShort(Object var1, int var2) {
		return this.getShort(var1, (long) var2);
	}
	@Deprecated
	public void putShort(Object var1, int var2, short var3) {
		this.putShort(var1, (long) var2, var3);
	}
	@Deprecated
	public char getChar(Object var1, int var2) {
		return this.getChar(var1, (long) var2);
	}
	@Deprecated
	public void putChar(Object var1, int var2, char var3) {
		this.putChar(var1, (long) var2, var3);
	}
	@Deprecated
	public long getLong(Object var1, int var2) {
		return this.getLong(var1, (long) var2);
	}
	@Deprecated
	public void putLong(Object var1, int var2, long var3) {
		this.putLong(var1, (long) var2, var3);
	}
	@Deprecated
	public float getFloat(Object var1, int var2) {
		return this.getFloat(var1, (long) var2);
	}
	@Deprecated
	public void putFloat(Object var1, int var2, float var3) {
		this.putFloat(var1, (long) var2, var3);
	}
	@Deprecated
	public double getDouble(Object var1, int var2) {
		return this.getDouble(var1, (long) var2);
	}
	@Deprecated
	public void putDouble(Object var1, int var2, double var3) {
		this.putDouble(var1, (long) var2, var3);
	}

	public native byte getByte(long var1);

	public native void putByte(long var1, byte var3);

	public native short getShort(long var1);

	public native void putShort(long var1, short var3);

	public native char getChar(long var1);

	public native void putChar(long var1, char var3);

	public native int getInt(long var1);

	public native void putInt(long var1, int var3);

	public native long getLong(long var1);

	public native void putLong(long var1, long var3);

	public native float getFloat(long var1);

	public native void putFloat(long var1, float var3);

	public native double getDouble(long var1);

	public native void putDouble(long var1, double var3);

	public native long getAddress(long var1);

	public native void putAddress(long var1, long var3);
	
	/** 分配一块新的本地内存，通过bytes指定内存块的大小(单位是byte)，返回新开辟的内存的地址 */
	public native long allocateMemory(long var1);
	/** 通过指定的内存地址address重新调整本地内存块的大小，调整后的内存块大小通过bytes指定(单位为byte) */
	public native long reallocateMemory(long var1, long var3);
	/** 将给定内存块中的所有字节设置为固定值(通常是0) */
	public native void setMemory(Object var1, long var2, long var4, byte var6);

	public void setMemory(long var1, long var3, byte var5) {
		this.setMemory((Object) null, var1, var3, var5);
	}

	public native void copyMemory(Object var1, long var2, Object var4,
			long var5, long var7);

	public void copyMemory(long var1, long var3, long var5) {
		this.copyMemory((Object) null, var1, (Object) null, var3, var5);
	}

	public native void freeMemory(long var1);

	@Deprecated
	public int fieldOffset(Field var1) {
		return Modifier.isStatic(var1.getModifiers()) ? (int) this
				.staticFieldOffset(var1) : (int) this.objectFieldOffset(var1);
	}

	@Deprecated
	public Object staticFieldBase(Class<?> var1) {
		Field[] var2 = var1.getDeclaredFields();

		for (int var3 = 0; var3 < var2.length; ++var3) {
			if (Modifier.isStatic(var2[var3].getModifiers())) {
				return this.staticFieldBase(var2[var3]);
			}
		}

		return null;
	}

	/** 返回给定的静态属性在它的类的存储分配中的位置(偏移地址) */
	public native long staticFieldOffset(Field var1);
	/** 返回给定的非静态属性在它的类的存储分配中的位置(偏移地址) */
	public native long objectFieldOffset(Field var1);
	/** 返回给定的静态属性的位置，配合staticFieldOffset方法使用 */
	public native Object staticFieldBase(Field var1);

	public native boolean shouldBeInitialized(Class<?> var1);
	public native void ensureClassInitialized(Class<?> var1);

	/** 返回数组类型的第一个元素的偏移地址(基础偏移地址) */
	public native int arrayBaseOffset(Class<?> var1);
	/** 
	 * 返回数组中元素与元素之间的偏移地址的增量 
	 * 与arrayBaseOffset方法配合使用就可以定位到任何一个元素的地址
	 */
	public native int arrayIndexScale(Class<?> var1);

	/** 获取本地指针的大小(单位是byte)，通常值为4或者8。常量ADDRESS_SIZE就是调用此方法 */
	public native int addressSize();
	/** 获取本地内存的页数，此值为2的幂次方 */
	public native int pageSize();
	
	public native Class<?> defineClass(String var1, byte[] var2, int var3,
			int var4, ClassLoader var5, ProtectionDomain var6);

	public native Class<?> defineAnonymousClass(Class<?> var1, byte[] var2,
			Object[] var3);

	public native Object allocateInstance(Class<?> var1)
			throws InstantiationException;

	@Deprecated
	public native void monitorEnter(Object var1);

	@Deprecated
	public native void monitorExit(Object var1);

	@Deprecated
	public native boolean tryMonitorEnter(Object var1);

	public native void throwException(Throwable var1);

	/**
	 * CAS机制	保证只有一个线程能操作成功
	 * @param var1 	待处理对象
	 * @param var2	待处理对象内存地址
	 * @param var4	对比对象
	 * @param var5	目标值
	 * @return	是否操作成功
	 */
	public final native boolean compareAndSwapObject(Object var1, long var2,
			Object var4, Object var5);
	public final native boolean compareAndSwapInt(Object var1, long var2,
			int var4, int var5);
	public final native boolean compareAndSwapLong(Object var1, long var2,
			long var4, long var6);

	public native Object getObjectVolatile(Object var1, long var2);

	public native void putObjectVolatile(Object var1, long var2, Object var4);

	public native int getIntVolatile(Object var1, long var2);

	public native void putIntVolatile(Object var1, long var2, int var4);

	public native boolean getBooleanVolatile(Object var1, long var2);

	public native void putBooleanVolatile(Object var1, long var2, boolean var4);

	public native byte getByteVolatile(Object var1, long var2);

	public native void putByteVolatile(Object var1, long var2, byte var4);

	public native short getShortVolatile(Object var1, long var2);

	public native void putShortVolatile(Object var1, long var2, short var4);

	public native char getCharVolatile(Object var1, long var2);

	public native void putCharVolatile(Object var1, long var2, char var4);

	public native long getLongVolatile(Object var1, long var2);

	public native void putLongVolatile(Object var1, long var2, long var4);

	public native float getFloatVolatile(Object var1, long var2);

	public native void putFloatVolatile(Object var1, long var2, float var4);

	public native double getDoubleVolatile(Object var1, long var2);

	public native void putDoubleVolatile(Object var1, long var2, double var4);

	public native void putOrderedObject(Object var1, long var2, Object var4);

	public native void putOrderedInt(Object var1, long var2, int var4);

	public native void putOrderedLong(Object var1, long var2, long var4);

	/** 释放被park创建的在一个线程上的阻塞。由于其不安全性，因此必须保证线程是存活的 */
	public native void unpark(Object var1);
	/** 阻塞当前线程，一直等道unpark方法被调用 */
	public native void park(boolean var1, long var2);

	public native int getLoadAverage(double[] var1, int var2);

	public final int getAndAddInt(Object var1, long var2, int var4) {
		int var5;
		do {
			var5 = this.getIntVolatile(var1, var2);
		} while (!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

		return var5;
	}

	public final long getAndAddLong(Object var1, long var2, long var4) {
		long var6;
		do {
			var6 = this.getLongVolatile(var1, var2);
		} while (!this.compareAndSwapLong(var1, var2, var6, var6 + var4));

		return var6;
	}

	public final int getAndSetInt(Object var1, long var2, int var4) {
		int var5;
		do {
			var5 = this.getIntVolatile(var1, var2);
		} while (!this.compareAndSwapInt(var1, var2, var5, var4));

		return var5;
	}

	public final long getAndSetLong(Object var1, long var2, long var4) {
		long var6;
		do {
			var6 = this.getLongVolatile(var1, var2);
		} while (!this.compareAndSwapLong(var1, var2, var6, var4));

		return var6;
	}

	public final Object getAndSetObject(Object var1, long var2, Object var4) {
		Object var5;
		do {
			var5 = this.getObjectVolatile(var1, var2);
		} while (!this.compareAndSwapObject(var1, var2, var5, var4));

		return var5;
	}
	
	/** 在该方法之前的所有读操作，一定在load屏障之前执行完成 */
	public native void loadFence();
	/** 在该方法之前的所有写操作，一定在store屏障之前执行完成 */
	public native void storeFence();
	/** 在该方法之前的所有读写操作，一定在full屏障之前执行完成，这个内存屏障相当于上面两个(load屏障和store屏障)的合体功能 */
	public native void fullFence();

	private static void throwIllegalAccessError() {
		throw new IllegalAccessError();
	}

	/** 注册本地native方法 */
	private static native void registerNatives();
	static {
		registerNatives();
		Reflection.registerMethodsToFilter(Unsafe.class,
				new String[]{"getUnsafe"});
		theUnsafe = new Unsafe();	//初始化Unsafe
		ARRAY_BOOLEAN_BASE_OFFSET = theUnsafe.arrayBaseOffset(boolean[].class);
		ARRAY_BYTE_BASE_OFFSET = theUnsafe.arrayBaseOffset(byte[].class);
		ARRAY_SHORT_BASE_OFFSET = theUnsafe.arrayBaseOffset(short[].class);
		ARRAY_CHAR_BASE_OFFSET = theUnsafe.arrayBaseOffset(char[].class);
		ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset(int[].class);
		ARRAY_LONG_BASE_OFFSET = theUnsafe.arrayBaseOffset(long[].class);
		ARRAY_FLOAT_BASE_OFFSET = theUnsafe.arrayBaseOffset(float[].class);
		ARRAY_DOUBLE_BASE_OFFSET = theUnsafe.arrayBaseOffset(double[].class);
		ARRAY_OBJECT_BASE_OFFSET = theUnsafe.arrayBaseOffset(Object[].class);
		ARRAY_BOOLEAN_INDEX_SCALE = theUnsafe.arrayIndexScale(boolean[].class);
		ARRAY_BYTE_INDEX_SCALE = theUnsafe.arrayIndexScale(byte[].class);
		ARRAY_SHORT_INDEX_SCALE = theUnsafe.arrayIndexScale(short[].class);
		ARRAY_CHAR_INDEX_SCALE = theUnsafe.arrayIndexScale(char[].class);
		ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale(int[].class);
		ARRAY_LONG_INDEX_SCALE = theUnsafe.arrayIndexScale(long[].class);
		ARRAY_FLOAT_INDEX_SCALE = theUnsafe.arrayIndexScale(float[].class);
		ARRAY_DOUBLE_INDEX_SCALE = theUnsafe.arrayIndexScale(double[].class);
		ARRAY_OBJECT_INDEX_SCALE = theUnsafe.arrayIndexScale(Object[].class);
		ADDRESS_SIZE = theUnsafe.addressSize();
	}
}