java Unsafe.java（二）

    上篇取得了Unsafe 实例， 下面分析Unsafe 的方法

1. 阻塞，释放操作

 public native void park(boolean isAbsolute, long time);

调用这个方法的线程阻塞直到下列情况的发生

(1).其他线程调用了unpark(this thread)

(2).被中断

(3).超时

(4). spuriously  (虚假唤醒)

释放线程操作： public native void unpark(Object thread);

2. 操作内存的方法

<span style="white-space:pre">	</span>@Test
	public void testAllocateMemory3() {
		long allocateMemory = unsafe.allocateMemory(4);
		unsafe.putInt(allocateMemory, 0x12345678);
		for (int i = 0; i < 4; i++) {
			byte byte1 = unsafe.getByte(allocateMemory + i);
			String hexString = Integer.toHexString(byte1);
			System.out.println(hexString);
		}
	}

  程序输出如下： 78，  56， 34， 12（具体输出与处理器的大端小端有关）， 程序先分配4个字节的内存空间， 然后在内存上写值， 最后按照字节取值。 即使是allocateMemory(1)， 也是可以的

 

	@Test
	public void testArray() {
		String[] strArray = new String[10];
		int offset = unsafe.arrayBaseOffset(strArray.getClass());
		int scale = unsafe.arrayIndexScale(strArray.getClass());
		System.out.println(offset);
		System.out.println(scale);

		byte[] bArray = new byte[10];
		bArray[0] = 48;
		int offset2 = unsafe.arrayBaseOffset(bArray.getClass());
		int scale2 = unsafe.arrayIndexScale(bArray.getClass());
		System.out.println(offset2);
		System.out.println(scale2);

		byte b = unsafe.getByte(bArray, 12);
		System.out.println(b);
	}

程序输出如下： 12， 4， 12， 1， 48. arrayBaseOffset 返回在数组对象中，数组元素的起始位置， 在jvm（32位机器） 中每个对象都有一个 “对象头”， 普通对象是8个字节（用来记录对应类在方法区的地址，和加锁情况等）， 数组对象是12个字节，其中多出来的4个字节用来记录数组的长度。 而arrayIndexScale() 返回的简单说就是数组元素的字节长度。两个方法中的  getByte (long)  和getByte(Object o, long)  体现了两种寻址方式， 一个是绝对地址， 一个是相对地址寻址，相对object 的地址。 

 public native long staticFieldOffset(Field f);
 public native long objectFieldOffset(Field f);

这两个方法可以得到字段相对地址

3. 类加载相关

<span style="white-space:pre">	</span>public static class ForTest{
		private void f() {
			System.out.println("just for test!!");
		}
	}
	@Test
	public void testDefineClass() throws Exception {
		URL resource = this.getClass().getClassLoader()
				.getResource("com/jdkstudy/juc/MyUnsafe$ForTest.class");
		File classFile = new File(resource.toURI());
		InputStream in = new FileInputStream(classFile);
		byte[] b = new byte[10000];
		int length = in.read(b);
		byte[] right = new byte[length];
		System.arraycopy(b, 0, right, 0, length);
		
		@SuppressWarnings("deprecation")
		Class<?> defineClass = unsafe.defineClass(
				"com.jdkstudy.juc.MyUnsafe$ForTest", b, 0, length);
		ForTest ins = (ForTest) defineClass.newInstance();
		ins.f();
		in.close();
	}

4. CAS 的操作

以public final native boolean compareAndSwapInt(Object o, long offset,   int expected,   int x);为例：

public class TestUnsafeCAS {
	private volatile int numCAS;
	public static void main(String[] args) throws InterruptedException {
		int threadNum = 10000;
		final CountDownLatch cdl1 = new CountDownLatch(threadNum);
		final CountDownLatch cdl2 = new CountDownLatch(1);
		final TestUnsafeCAS instance = new TestUnsafeCAS();

		for (int i = 0; i < threadNum; i++) {
			Thread t = new Thread(new Runnable() {

				@Override
				public void run() {
					try {
						cdl2.await();
						//something()
						//instance.numCAS++; // use ++ without CAS
						for(;;) {
							int expect = instance.numCAS;
							// use CAS to update
							if(unsafe.compareAndSwapInt(instance, numCASOffset, expect, expect + 1)) break;
						}
						cdl1.countDown();
					} catch (Exception e) {
					}
				}
			});
			t.start();
		}
		cdl2.countDown();
		cdl1.await();
		System.out.println(instance.numCAS);
	}

	private static final Unsafe unsafe = MyUnsafe.getUnsafe();
	private final static long numCASOffset;
	static {
		try {
			numCASOffset = unsafe.objectFieldOffset(TestUnsafeCAS.class
					.getDeclaredField("numCAS"));
		} catch (Exception ex) {
			throw new Error(ex);
		}
	}
}

如果直接使用 ++ 肯定会有并发问题， 会出现numCAS <threadNum 。 但是使用CAS 操作numCAS就不会有这个问题（失败了会重试直到成功）。 AtomicInteger已经帮我们实现了这样的功能， 参看AtomicInteger 源码会发现， 其就是用volatile的int变量来保存一个值， 用cas来更新这个值。