并行编程(1) - sum.msic.Unsafe 一

      相信看过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各个方法的详细应用，将会具体分析。