并行编程 - sum.msic.Unsafe 一

Posted 2020-09-20 liguangsunls

      相信看过java源代码的同学。对 sum.msic.Unsafe 这个类并不陌生，特别是在java.util.concurrent包有非常多的使用。

      sum.msic.Unsafe源代码：      http://www.docjar.com/html/api/sun/misc/Unsafe.java.html

                            javadoc：      http://www.docjar.com/docs/api/sun/misc/Unsafe.html

      sum.msic.Unsafe是一个运行低级别（硬件级别的原子操作），不安全操作的方法结合，由于java无法訪问到系统底层，所以我们能够看到sum.msic.Unsafe类大部分都是native的本地方法。尽管该类的方法都是pulblic的，可是我们无法在编程中调用Unsafe（在JDK中能够随意调用），该类仅仅能在授信的代码中使用它的实例。

     先介绍下CAS（Compare And Swap）。按字面的理解就是比較并交换。

CAS包括三个操作值：内存地址，新值，预期原值。假设内存地址中的值和预期原值一样，那么则会替换成新值，否则。将不做不论什么操作。在sum.msic.Unsafe 类中有大量的compareAndSwap***方法。比如：compareAndSwapInt，compareAndSwapLong，compareAndSwapObject等等。

AtomicBoolean类，Unsafe对象初始化：
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();

获取Unsafe实例静态方法：

public static Unsafe getUnsafe() {
      Class cc = sun.reflect.Reflection.getCallerClass(2);
      if (cc.getClassLoader() != null)
            throw new SecurityException("Unsafe");
      return theUnsafe;
 }

接下来简介一下sum.msic.Unsafe的一些方法：

//扩充内存
public native long reallocateMemory(long address, long bytes);

//分配内存
public native long allocateMemory(long bytes);

//释放内存
public native void freeMemory(long address);

//在给定的内存块中设置值
public native void setMemory(Object o, long offset, long bytes, byte value);

//从一个内存块复制到还有一个内存块
public native void copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes);

//获取值。无论java的訪问限制，其它有相似的getDouble，getLong，getChar等等
public native Object getObject(Object o, long offset);

//设置值，无论java的訪问限制，其它有相似的putDouble，putLong，putChar等等
public native void putObject(Object o, long offset);

//从一个给定的内存地址获取本地指针。假设不是allocateMemory方法的，结果将不确定
public native long getAddress(long address);

//存储一个本地指针到一个给定的内存地址,假设地址不是allocateMemory方法的，结果将不确定
public native void putAddress(long address, long x);

//该方法返回给定field的内存地址偏移量，这个值对于给定的filed是唯一的且是固定不变的
public native long staticFieldOffset(Field f);

//报告一个给定的字段的位置。无论这个字段是private，public还是保护类型，和staticFieldBase结合使用
public native long objectFieldOffset(Field f);

//获取一个给定字段的位置
public native Object staticFieldBase(Field f);

//确保给定class被初始化，这往往须要结合基类的静态域（field）
public native void ensureClassInitialized(Class c);

//能够获取数组第一个元素的偏移地址
public native int arrayBaseOffset(Class arrayClass);

//能够获取数组的转换因子。也就是数组中元素的增量地址。
将arrayBaseOffset与arrayIndexScale配合使用， 能够定位数组中每一个元素在内存中的位置
public native int arrayIndexScale(Class arrayClass);

//获取本机内存的页数。这个值永远都是2的幂次方
public native int pageSize();

//告诉虚拟机定义了一个没有安全检查的类，默认情况下这个类载入器和保护域来着调用者类
public native Class defineClass(String name, byte[] b, int off, int len, ClassLoader loader, ProtectionDomain protectionDomain);

//定义一个类，可是不让它知道类载入器和系统字典
public native Class defineAnonymousClass(Class hostClass, byte[] data, Object[] cpPatches);

//锁定对象，必须是没有被锁的
public native void monitorEnter(Object o);

//解锁对象
public native void monitorExit(Object o);

//试图锁定对象，返回true或false是否锁定成功，假设锁定，必须用monitorExit解锁
public native boolean tryMonitorEnter(Object o);

//引发异常，没有通知
public native void throwException(Throwable ee);

//CAS，相似的有compareAndSwapInt,compareAndSwapLong,compareAndSwapBoolean,compareAndSwapChar等等。
public final native boolean compareAndSwapObject(Object o, long offset,  Object expected, Object x);

// 该方法获取对象中offset偏移地址相应的整型field的值,支持volatile load语义。相似的方法有getIntVolatile，getBooleanVolatile等等
public native Object getObjectVolatile(Object o, long offset); 

//线程调用该方法，线程将一直堵塞直到超时。或者是中断条件出现。
public native void park(boolean isAbsolute, long time);

//终止挂起的线程，恢复正常.java.util.concurrent包中挂起操作都是在LockSupport类实现的。也正是使用这两个方法，兴许将会把java.util.concurrent包相关的源代码分析整理出来。
public native void unpark(Object thread);

//获取系统在不同一时候间系统的负载情况
public native int getLoadAverage(double[] loadavg, int nelems);

//创建一个类的实例，不须要调用它的构造函数、初使化代码、各种JVM安全检查以及其它的一些底层的东西。即使构造函数是私有，我们也能够通过这种方法创建它的实例,对于单例模式。简直是噩梦，哈哈
public native Object allocateInstance(Class cls) throws InstantiationException;

sum.msic.Unsafe类有一个私有的实例：theUnsafe

private static final Unsafe theUnsafe = new Unsafe();

我们能够通过反射机制获取Unsafe实例，以下举一个简单的样例：

public class UnsafeTest {
	private static Unsafe unsafe;

	public static void main(String[] args) throws Exception {
		try {
			//通过反射获取rt.jar下的Unsafe类
			Field field = Unsafe.class.getDeclaredField("theUnsafe");
			field.setAccessible(true);
			unsafe = (Unsafe) field.get(null);
			Integer target = 12;
			//compareAndSwapInt方法的属性各自是：目标对象实例，目标对象属性偏移量。当前预期值，要设的值.
			//compareAndSwapInt方法是通过反射改动对象的值，详细改动对象以下那个值。能够通过偏移量。对象字段的偏移量能够通过objectFieldOffset获取
			System.out.println(unsafe.compareAndSwapInt(target, 12, 11, 10));
			System.out.println(target);
		} catch (Exception e) {
			System.out.println("Get Unsafe instance occur error" + e);
		}
	}
}

执行以上代码，设置Eclipse：
将Windows->Preferences->Java-Complicer->Errors/Warnings->Deprecated and restricted API，中的Forbidden references(access rules)设置为Warning，即能够编译通过。

最后：Unsafe类是没有安全保证，稍有疏忽或是使用不当，都可能造成JVM崩溃。

兴许将会整理一下java.util.concurrent包相关类的源代码分析，对于Unsafe各个方法的具体应用，将会具体分析。