From 4c15c59a9228044869166db9a42d88bbb0827b60 Mon Sep 17 00:00:00 2001
From: Apollo2016926 <944644308@qq.com>
Date: Fri, 20 Dec 2019 17:16:57 +0800
Subject: [PATCH 1/2] step_1

---
 week_02/61/AtomicInteger.md |  151 ++++
 week_02/61/Unsafe.md        | 1324 +++++++++++++++++++++++++++++++++++
 week_02/61/unsafe.png       |  Bin 0 -> 1656054 bytes
 3 files changed, 1475 insertions(+)
 create mode 100644 week_02/61/AtomicInteger.md
 create mode 100644 week_02/61/Unsafe.md
 create mode 100644 week_02/61/unsafe.png

diff --git a/week_02/61/AtomicInteger.md b/week_02/61/AtomicInteger.md
new file mode 100644
index 0000000..92a0ae9
--- /dev/null
+++ b/week_02/61/AtomicInteger.md
@@ -0,0 +1,151 @@
+# < center>AtomicInteger源码分析< /center>
+
+本文基于jdk1.8
+
+### 简介
+
+Atomic包是[Java](http://lib.csdn.net/base/17).util.concurrent下的另一个专门为线程安全设计的Java包，包含多个原子操作类。这个包里面提供了一组原子变量类。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的，不会阻塞线程(或者说只是在硬件级别上阻塞了)。可以对基本数据、数组中的基本数据、对类中的基本数据进行操作。原子变量类相当于一种泛化的volatile变量，能够支持原子的和有条件的读-改-写操作 
+
+### 源码解析
+
++ 初始化
+
+```java
+// 拿到Unsafe实例
+private static final Unsafe unsafe = Unsafe.getUnsafe();
+private static final long valueOffset;//变量value的内存偏移量
+//通过unsafe获取AtomicInteger类下value字段的内存偏移量
+static {
+    try {
+        valueOffset = unsafe.objectFieldOffset
+            (AtomicInteger.class.getDeclaredField("value"));
+    } catch (Exception ex) { throw new Error(ex); }
+}
+
+private volatile int value;// volatile修饰的变量value 保证内存可见、防止指令重排
+```
+
++ 构造函数
+
+```java
+// value=initialValue
+public AtomicInteger(int initialValue) {
+    value = initialValue;
+}
+
+//无参构造默认value=0
+public AtomicInteger() {
+}
+```
+
+
+
++ set() get()
+
+```java
+// 返回value
+public final int get() {
+    return value;
+}
+
+// 将传入的值替换value
+public final void set(int newValue) {
+    value = newValue;
+}
+```
+
+```java
+//最终把值设置为newValue，使用该方法后，其他线程在一段时间内还会获取到旧值
+public final void lazySet(int newValue) {
+    unsafe.putOrderedInt(this, valueOffset, newValue);
+}
+//设置为newValue 并返回旧值
+public final int getAndSet(int newValue) {
+    return unsafe.getAndSetInt(this, valueOffset, newValue);
+}
+```
+
+```java
+//jdk1.8时这两个方法底层调用的是同一个方法 所以认为并无区别  查阅资料到了1.9 weakCompareAndSet才有特殊实现
+//如果调用此方法对象的值等于expect，则设置值为update并返回true;反之不修改返回false
+public final boolean compareAndSet(int expect, int update) {
+    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
+}
+
+public final boolean weakCompareAndSet(int expect, int update) {
+    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
+}
+```
+
+```java
+// 返回原值并将当前对象的value+1
+public final int getAndIncrement() {
+        return unsafe.getAndAddInt(this, valueOffset, 1);
+    }
+// 返回原值并将当前对象的value+ -1
+    public final int getAndDecrement() {
+        return unsafe.getAndAddInt(this, valueOffset, -1);
+    }
+
+  // 返回原值并将当前对象的value+delta
+    public final int getAndAdd(int delta) {
+        return unsafe.getAndAddInt(this, valueOffset, delta);
+    }
+
+   // 将当前对象的value+1 并返回计算后的结果
+    public final int incrementAndGet() {
+        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
+    }
+// 将当前对象的value+-1 并返回计算后的结果
+    public final int decrementAndGet() {
+        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
+    }
+
+   // 将当前对象的value+delta 并返回计算后的结果
+    public final int addAndGet(int delta) {
+        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
+    }
+
+// 1.8新增方法，更新当前值，返回以前的值
+    public final int getAndUpdate(IntUnaryOperator updateFunction) {
+        int prev, next;
+        do {
+            prev = get();
+            next = updateFunction.applyAsInt(prev);
+        } while (!compareAndSet(prev, next));
+        return prev;
+    }
+
+// 1.8新增方法，更新当前值，返回更新后的值
+    public final int updateAndGet(IntUnaryOperator updateFunction) {
+        int prev, next;
+        do {
+            prev = get();
+            next = updateFunction.applyAsInt(prev);
+        } while (!compareAndSet(prev, next));
+        return next;
+    }
+
+// 1.8新增方法，更新当前值，返回以前的值
+    public final int getAndAccumulate(int x,
+                                      IntBinaryOperator accumulatorFunction) {
+        int prev, next;
+        do {
+            prev = get();
+            next = accumulatorFunction.applyAsInt(prev, x);
+        } while (!compareAndSet(prev, next));
+        return prev;
+    }
+
+  // 1.8新增方法，更新当前值，返回更新后的值
+    public final int accumulateAndGet(int x,
+                                      IntBinaryOperator accumulatorFunction) {
+        int prev, next;
+        do {
+            prev = get();
+            next = accumulatorFunction.applyAsInt(prev, x);
+        } while (!compareAndSet(prev, next));
+        return next;
+    }
+
+```
\ No newline at end of file
diff --git a/week_02/61/Unsafe.md b/week_02/61/Unsafe.md
new file mode 100644
index 0000000..5ffff83
--- /dev/null
+++ b/week_02/61/Unsafe.md
@@ -0,0 +1,1324 @@
+# <center>unsafe源码</center>
+
+
+
+## 简介
+
+Java和C++语言的一个重要区别就是Java中我们无法直接操作一块内存区域，不能像C++中那样可以自己申请内存和释放内存。Java中的Unsafe类为我们提供了类似C++手动管理内存的能力。
+ Unsafe类，全限定名是sun.misc.Unsafe，从名字中我们可以看出来这个类对普通程序员来说是“危险”的，。但是它的很多方法都是很偏向底层的，一般人使用可能会对系统造成不好的影响，所以java官方不推荐使用这个类。但是不影响我们分析这个类，并且它也是分析并发的基础。
+
+
+
+## 源码解析
+
+  ### 类的属性及初始化
+
+```java
+    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;
+
+    private static native void registerNatives();
+
+    private Unsafe() {
+    }
+
+    @CallerSensitive//调用Reflection.getCallerClass()需要由bootstrap class loader、extension class loader加载的类可以调用
+
+    public static Unsafe getUnsafe() {
+        Class var0 = Reflection.getCallerClass();
+        if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
+            throw new SecurityException("Unsafe");
+        } else {
+            return theUnsafe;
+        }
+    }
+ static {
+     /*Java有两种方法：Java方法和本地方法。Java方法是由Java语言编写，编译成字节码，存储在class文件中。本地方法是由其他语言（比如C，C++，或者汇编）编写的，编译成和处理器相关的机器代码。本地方法保存在动态连接库中，格式是各个平台专有的。Java方法是平台无关的，单本地方法却不是。运行中的Java程序调用本地方法时，虚拟机装载包含这个本地方法的动态库，并调用这个方法。本地方法是联系Java程序和底层主机操作系统的连接方法。
+     一个Java程序要想调用一个本地方法，需要执行两个步骤：第一，通过System.loadLibrary()将包含本地方法实现的动态文件加载进内存；第二，当Java程序需要调用本地方法时，虚拟机在加载的动态文件中定位并链接该本地方法，从而得以执行本地方法。registerNatives()方法的作用就是取代第二步，让程序主动将本地方法链接到调用方，当Java程序需要调用本地方法时就可以直接调用，而不需要虚拟机再去定位并链接。
+   类被加载的时候，注册的方法就是该类所包含的除了registerNatives()方法以外的所有本地方法。
+     */
+        registerNatives();
+        Reflection.registerMethodsToFilter(Unsafe.class, new String[]{"getUnsafe"});
+        theUnsafe = new 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();
+    }
+```
+
+
+
+
+
+
+
+unsafe主要功能：
+
+![](./unsafe.png)
+
+### 对象相关方法
+
+* ```java
+  // 通过给定的Java变量获取引用值。这里实际上是获取一个Java对象o中，获取偏移地址为offset的属性的值，此方法可以突破修饰符的抑制，也就是无视private、protected和default修饰符。类似的方法有getInt、getDouble等等
+  public native Object getObject(Object var1, long var2);
+  ```
+
+* ```java
+  // 将引用值存储到给定的Java变量中。这里实际上是设置一个Java对象o中偏移地址为offset的属性的值为x，此方法可以突破修饰符的抑制，也就是无视private、protected和default修饰符。类似的方法有putInt、putDouble等等。
+  public native void putObject(Object var1, long var2, Object var4);
+  ```
+
+* ```java
+  // 此方法和上面的getObject功能类似，不过附加了'volatile'加载语义，也就是强制从主存中获取属性值。类似的方法有getIntVolatile、getDoubleVolatile等等。这个方法要求被使用的属性被volatile修饰，否则功能和getObject方法相同。
+  public native Object getObjectVolatile(Object var1, long var2);
+  ```
+
+* ```java
+  // 此方法和上面的putObject功能类似，不过附加了'volatile'加载语义，也就是设置值的时候强制(JMM会保证获得锁到释放锁之间所有对象的状态更新都会在锁被释放之后)更新到主存，从而保证这些变更对其他线程是可见的。类似的方法有putIntVolatile、putDoubleVolatile等等。这个方法要求被使用的属性被volatile修饰，否则功能和putObject方法相同。
+  public native void putObjectVolatile(Object var1, long var2, Object var4);
+  ```
+
+* ```java
+  // 返回给定的静态属性在它的类的存储分配中的位置(偏移地址)。不要在这个偏移量上执行任何类型的算术运算，它只是一个被传递给不安全的堆内存访问器的cookie。注意：这个方法仅仅针对静态属性，使用在非静态属性上会抛异常。
+  public native long staticFieldOffset(Field var1);
+  // 返回给定的非静态属性在它的类的存储分配中的位置(偏移地址)。不要在这个偏移量上执行任何类型的算术运算，它只是一个被传递给不安全的堆内存访问器的cookie。注意：这个方法仅仅针对非静态属性，使用在静态属性上会抛异常。
+  public native long objectFieldOffset(Field var1);
+  // 返回给定的静态属性的位置，配合staticFieldOffset方法使用。实际上，这个方法返回值就是静态属性所在的Class对象的一个内存快照。注释中说到，此方法返回的Object有可能为null，它只是一个'cookie'而不是真实的对象，不要直接使用的它的实例中的获取属性和设置属性的方法，它的作用只是方便调用上面提到的像getInt(Object,long)等等的任意方法。
+  public native Object staticFieldBase(Field var1);
+  ```
+
+* ```java
+  // 检测给定的类是否需要初始化。通常需要使用在获取一个类的静态属性的时候(因为一个类如果没初始化，它的静态属性也不会初始化)。 此方法当且仅当ensureClassInitialized方法不生效的时候才返回false。
+  public native boolean shouldBeInitialized(Class<?> var1);
+  // 检测给定的类是否已经初始化。通常需要使用在获取一个类的静态属性的时候(因为一个类如果没初始化，它的静态属性也不会初始化)。
+  public native void ensureClassInitialized(Class<?> var1);
+  ```
+
+* ```java
+  // 返回数组中第一个元素的偏移地址
+  public native int arrayBaseOffset(Class<?> var1);
+  // 数组中每个元素的增量地址，可以通过 arrayBaseOffset和arrayIndexScale确定所有的数组元素
+  public native int arrayIndexScale(Class<?> var1);
+  ```
+
+* ```java
+  // 告诉JVM定义一个类，返回类实例，此方法会跳过JVM的所有安全检查。默认情况下，ClassLoader(类加载器)和ProtectionDomain(保护域)实例应该来源于调用者
+  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;
+  
+  ```
+### 直接内存操作
+
+* ```java
+  //分配一块新的本地内存，通过bytes指定内存块的大小(单位是byte)，返回新开辟的内存的地址。如果内存块的内容不被初始化，那么它们一般会变成内存垃圾。生成的本机指针永远不会为零，并将对所有值类型进行对齐。可以通过freeMemory方法释放内存块，或者通过reallocateMemory方法调整内存块大小。bytes值为负数或者过大会抛出IllegalArgumentException异常，如果系统拒绝分配内存会抛出OutOfMemoryError异常
+  public native long allocateMemory(long var1);
+  //通过指定的内存地址address重新调整本地内存块的大小，调整后的内存块大小通过bytes指定(单位为byte)。可以通过freeMemory方法释放内存块，或者通过reallocateMemory方法调整内存块大小。bytes值为负数或者过大会抛出IllegalArgumentException异常，如果系统拒绝分配内存会抛出OutOfMemoryError异常
+  public native long reallocateMemory(long var1, long var3);
+  //将给定内存块中的所有字节设置为固定值(通常是0)。内存块的地址由对象引用o和偏移地址共同决定，如果对象引用o为null，offset就是绝对地址。第三个参数就是内存块的大小，如果使用allocateMemory进行内存开辟的话，这里的值应该和allocateMemory的参数一致。value就是设置的固定值，一般为0(这里可以参考netty的DirectByteBuffer)
+  public native void setMemory(Object var1, long var2, long var4, byte var6);
+  // 内存复制
+  public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);
+  // 清除内存
+  public native void freeMemory(long var1);
+  ```
+
+### CAS相关
+
++ ```java
+  /* 针对Object对象进行CAS操作。即是对应Java变量引用o，原子性地更新o中偏移地址为offset的属性的值为x，当且仅的偏移地址为offset的属性的当前值为expected才会更新成功返回true，否则返回false。
+  o：目标Java变量引用。
+  offset：目标Java变量中的目标属性的偏移地址。
+  expected：目标Java变量中的目标属性的期望的当前值。
+  x：目标Java变量中的目标属性的目标更新值。
+  类似的方法有compareAndSwapInt和compareAndSwapLong，在Jdk8中基于CAS扩展出来的方法有getAndAddInt、getAndAddLong、getAndSetInt、getAndSetLong、getAndSetObject，它们的作用都是：通过CAS设置新的值，返回旧的值*/
+  public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
+  ```
+
+### 线程调度
+
++ ```java
+  // 释放被park创建的在一个线程上的阻塞。这个方法也可以被使用来终止一个先前调用park导致的阻塞。这个操作是不安全的，因此必须保证线程是存活的(thread has not been destroyed)。从Java代码中判断一个线程是否存活的是显而易见的，但是从native代码中这机会是不可能自动完成的。
+  public native void unpark(Object var1);
+  // 阻塞当前线程直到一个unpark方法出现(被调用)、一个用于unpark方法已经出现过(在此park方法调用之前已经调用过)、线程被中断或者time时间到期(也就是阻塞超时)。在time非零的情况下，如果isAbsolute为true，time是相对于新纪元之后的毫秒，否则time表示纳秒。这个方法执行时也可能不合理地返回(没有具体原因)。并发包java.util.concurrent中的框架对线程的挂起操作被封装在LockSupport类中，LockSupport类中有各种版本pack方法，但最终都调用了Unsafe#park()方法。
+  public native void park(boolean var1, long var2);
+  ```
+
+
+
+### 内存屏障
+
+- ```java
+  public native void loadFence();//保证在这个屏障之前的所有读操作都已经完成。
+  public native void storeFence();//保证在这个屏障之前的所有写操作都已经完成。
+  public native void fullFence();//保证在这个屏障之前的所有读写操作都已经完成
+  ```
+
+  
+
+ ## 源码附录
+
+~~~ java
+package sun.misc;
+
+import java.security.*;
+import java.lang.reflect.*;
+
+import sun.reflect.CallerSensitive;
+import sun.reflect.Reflection;
+
+
+/**
+ * A collection of methods for performing low-level, unsafe operations.
+ * Although the class and all methods are public, use of this class is
+ * limited because only trusted code can obtain instances of it.
+ *
+ * @author John R. Rose
+ * @see #getUnsafe
+ */
+
+public final class Unsafe {
+
+    private static native void registerNatives();
+    static {
+        registerNatives();
+        sun.reflect.Reflection.registerMethodsToFilter(Unsafe.class, "getUnsafe");
+    }
+
+    private Unsafe() {}
+
+    private static final Unsafe theUnsafe = new Unsafe();
+
+    /**
+     * Provides the caller with the capability of performing unsafe
+     * operations.
+     *
+     * <p> The returned <code>Unsafe</code> object should be carefully guarded
+     * by the caller, since it can be used to read and write data at arbitrary
+     * memory addresses.  It must never be passed to untrusted code.
+     *
+     * <p> Most methods in this class are very low-level, and correspond to a
+     * small number of hardware instructions (on typical machines).  Compilers
+     * are encouraged to optimize these methods accordingly.
+     *
+     * <p> Here is a suggested idiom for using unsafe operations:
+     *
+     * <blockquote><pre>
+     * class MyTrustedClass {
+     *   private static final Unsafe unsafe = Unsafe.getUnsafe();
+     *   ...
+     *   private long myCountAddress = ...;
+     *   public int getCount() { return unsafe.getByte(myCountAddress); }
+     * }
+     * </pre></blockquote>
+     *
+     * (It may assist compilers to make the local variable be
+     * <code>final</code>.)
+     *
+     * @exception  SecurityException  if a security manager exists and its
+     *             <code>checkPropertiesAccess</code> method doesn't allow
+     *             access to the system properties.
+     */
+    @CallerSensitive
+    public static Unsafe getUnsafe() {
+        Class<?> caller = Reflection.getCallerClass();
+        if (!VM.isSystemDomainLoader(caller.getClassLoader()))
+            throw new SecurityException("Unsafe");
+        return theUnsafe;
+    }
+
+    /// peek and poke operations
+    /// (compilers should optimize these to memory ops)
+
+    // These work on object fields in the Java heap.
+    // They will not work on elements of packed arrays.
+
+    /**
+     * Fetches a value from a given Java variable.
+     * More specifically, fetches a field or array element within the given
+     * object <code>o</code> at the given offset, or (if <code>o</code> is
+     * null) from the memory address whose numerical value is the given
+     * offset.
+     * <p>
+     * The results are undefined unless one of the following cases is true:
+     * <ul>
+     * <li>The offset was obtained from {@link #objectFieldOffset} on
+     * the {@link java.lang.reflect.Field} of some Java field and the object
+     * referred to by <code>o</code> is of a class compatible with that
+     * field's class.
+     *
+     * <li>The offset and object reference <code>o</code> (either null or
+     * non-null) were both obtained via {@link #staticFieldOffset}
+     * and {@link #staticFieldBase} (respectively) from the
+     * reflective {@link Field} representation of some Java field.
+     *
+     * <li>The object referred to by <code>o</code> is an array, and the offset
+     * is an integer of the form <code>B+N*S</code>, where <code>N</code> is
+     * a valid index into the array, and <code>B</code> and <code>S</code> are
+     * the values obtained by {@link #arrayBaseOffset} and {@link
+     * #arrayIndexScale} (respectively) from the array's class.  The value
+     * referred to is the <code>N</code><em>th</em> element of the array.
+     *
+     * </ul>
+     * <p>
+     * If one of the above cases is true, the call references a specific Java
+     * variable (field or array element).  However, the results are undefined
+     * if that variable is not in fact of the type returned by this method.
+     * <p>
+     * This method refers to a variable by means of two parameters, and so
+     * it provides (in effect) a <em>double-register</em> addressing mode
+     * for Java variables.  When the object reference is null, this method
+     * uses its offset as an absolute address.  This is similar in operation
+     * to methods such as {@link #getInt(long)}, which provide (in effect) a
+     * <em>single-register</em> addressing mode for non-Java variables.
+     * However, because Java variables may have a different layout in memory
+     * from non-Java variables, programmers should not assume that these
+     * two addressing modes are ever equivalent.  Also, programmers should
+     * remember that offsets from the double-register addressing mode cannot
+     * be portably confused with longs used in the single-register addressing
+     * mode.
+     *
+     * @param o Java heap object in which the variable resides, if any, else
+     *        null
+     * @param offset indication of where the variable resides in a Java heap
+     *        object, if any, else a memory address locating the variable
+     *        statically
+     * @return the value fetched from the indicated Java variable
+     * @throws RuntimeException No defined exceptions are thrown, not even
+     *         {@link NullPointerException}
+     */
+    public native int getInt(Object o, long offset);
+
+    /**
+     * Stores a value into a given Java variable.
+     * <p>
+     * The first two parameters are interpreted exactly as with
+     * {@link #getInt(Object, long)} to refer to a specific
+     * Java variable (field or array element).  The given value
+     * is stored into that variable.
+     * <p>
+     * The variable must be of the same type as the method
+     * parameter <code>x</code>.
+     *
+     * @param o Java heap object in which the variable resides, if any, else
+     *        null
+     * @param offset indication of where the variable resides in a Java heap
+     *        object, if any, else a memory address locating the variable
+     *        statically
+     * @param x the value to store into the indicated Java variable
+     * @throws RuntimeException No defined exceptions are thrown, not even
+     *         {@link NullPointerException}
+     */
+    public native void putInt(Object o, long offset, int x);
+
+    /**
+     * Fetches a reference value from a given Java variable.
+     * @see #getInt(Object, long)
+     */
+    public native Object getObject(Object o, long offset);
+
+    /**
+     * Stores a reference value into a given Java variable.
+     * <p>
+     * Unless the reference <code>x</code> being stored is either null
+     * or matches the field type, the results are undefined.
+     * If the reference <code>o</code> is non-null, car marks or
+     * other store barriers for that object (if the VM requires them)
+     * are updated.
+     * @see #putInt(Object, int, int)
+     */
+    public native void putObject(Object o, long offset, Object x);
+
+    /** @see #getInt(Object, long) */
+    public native boolean getBoolean(Object o, long offset);
+    /** @see #putInt(Object, int, int) */
+    public native void    putBoolean(Object o, long offset, boolean x);
+    /** @see #getInt(Object, long) */
+    public native byte    getByte(Object o, long offset);
+    /** @see #putInt(Object, int, int) */
+    public native void    putByte(Object o, long offset, byte x);
+    /** @see #getInt(Object, long) */
+    public native short   getShort(Object o, long offset);
+    /** @see #putInt(Object, int, int) */
+    public native void    putShort(Object o, long offset, short x);
+    /** @see #getInt(Object, long) */
+    public native char    getChar(Object o, long offset);
+    /** @see #putInt(Object, int, int) */
+    public native void    putChar(Object o, long offset, char x);
+    /** @see #getInt(Object, long) */
+    public native long    getLong(Object o, long offset);
+    /** @see #putInt(Object, int, int) */
+    public native void    putLong(Object o, long offset, long x);
+    /** @see #getInt(Object, long) */
+    public native float   getFloat(Object o, long offset);
+    /** @see #putInt(Object, int, int) */
+    public native void    putFloat(Object o, long offset, float x);
+    /** @see #getInt(Object, long) */
+    public native double  getDouble(Object o, long offset);
+    /** @see #putInt(Object, int, int) */
+    public native void    putDouble(Object o, long offset, double x);
+
+    /**
+     * This method, like all others with 32-bit offsets, was native
+     * in a previous release but is now a wrapper which simply casts
+     * the offset to a long value.  It provides backward compatibility
+     * with bytecodes compiled against 1.4.
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public int getInt(Object o, int offset) {
+        return getInt(o, (long)offset);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public void putInt(Object o, int offset, int x) {
+        putInt(o, (long)offset, x);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public Object getObject(Object o, int offset) {
+        return getObject(o, (long)offset);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public void putObject(Object o, int offset, Object x) {
+        putObject(o, (long)offset, x);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public boolean getBoolean(Object o, int offset) {
+        return getBoolean(o, (long)offset);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public void putBoolean(Object o, int offset, boolean x) {
+        putBoolean(o, (long)offset, x);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public byte getByte(Object o, int offset) {
+        return getByte(o, (long)offset);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public void putByte(Object o, int offset, byte x) {
+        putByte(o, (long)offset, x);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public short getShort(Object o, int offset) {
+        return getShort(o, (long)offset);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public void putShort(Object o, int offset, short x) {
+        putShort(o, (long)offset, x);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public char getChar(Object o, int offset) {
+        return getChar(o, (long)offset);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public void putChar(Object o, int offset, char x) {
+        putChar(o, (long)offset, x);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public long getLong(Object o, int offset) {
+        return getLong(o, (long)offset);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public void putLong(Object o, int offset, long x) {
+        putLong(o, (long)offset, x);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public float getFloat(Object o, int offset) {
+        return getFloat(o, (long)offset);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public void putFloat(Object o, int offset, float x) {
+        putFloat(o, (long)offset, x);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public double getDouble(Object o, int offset) {
+        return getDouble(o, (long)offset);
+    }
+
+    /**
+     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
+     * See {@link #staticFieldOffset}.
+     */
+    @Deprecated
+    public void putDouble(Object o, int offset, double x) {
+        putDouble(o, (long)offset, x);
+    }
+
+    // These work on values in the C heap.
+
+    /**
+     * Fetches a value from a given memory address.  If the address is zero, or
+     * does not point into a block obtained from {@link #allocateMemory}, the
+     * results are undefined.
+     *
+     * @see #allocateMemory
+     */
+    public native byte    getByte(long address);
+
+    /**
+     * Stores a value into a given memory address.  If the address is zero, or
+     * does not point into a block obtained from {@link #allocateMemory}, the
+     * results are undefined.
+     *
+     * @see #getByte(long)
+     */
+    public native void    putByte(long address, byte x);
+
+    /** @see #getByte(long) */
+    public native short   getShort(long address);
+    /** @see #putByte(long, byte) */
+    public native void    putShort(long address, short x);
+    /** @see #getByte(long) */
+    public native char    getChar(long address);
+    /** @see #putByte(long, byte) */
+    public native void    putChar(long address, char x);
+    /** @see #getByte(long) */
+    public native int     getInt(long address);
+    /** @see #putByte(long, byte) */
+    public native void    putInt(long address, int x);
+    /** @see #getByte(long) */
+    public native long    getLong(long address);
+    /** @see #putByte(long, byte) */
+    public native void    putLong(long address, long x);
+    /** @see #getByte(long) */
+    public native float   getFloat(long address);
+    /** @see #putByte(long, byte) */
+    public native void    putFloat(long address, float x);
+    /** @see #getByte(long) */
+    public native double  getDouble(long address);
+    /** @see #putByte(long, byte) */
+    public native void    putDouble(long address, double x);
+
+    /**
+     * Fetches a native pointer from a given memory address.  If the address is
+     * zero, or does not point into a block obtained from {@link
+     * #allocateMemory}, the results are undefined.
+     *
+     * <p> If the native pointer is less than 64 bits wide, it is extended as
+     * an unsigned number to a Java long.  The pointer may be indexed by any
+     * given byte offset, simply by adding that offset (as a simple integer) to
+     * the long representing the pointer.  The number of bytes actually read
+     * from the target address maybe determined by consulting {@link
+     * #addressSize}.
+     *
+     * @see #allocateMemory
+     */
+    public native long getAddress(long address);
+
+    /**
+     * Stores a native pointer into a given memory address.  If the address is
+     * zero, or does not point into a block obtained from {@link
+     * #allocateMemory}, the results are undefined.
+     *
+     * <p> The number of bytes actually written at the target address maybe
+     * determined by consulting {@link #addressSize}.
+     *
+     * @see #getAddress(long)
+     */
+    public native void putAddress(long address, long x);
+
+    /// wrappers for malloc, realloc, free:
+
+    /**
+     * Allocates a new block of native memory, of the given size in bytes.  The
+     * contents of the memory are uninitialized; they will generally be
+     * garbage.  The resulting native pointer will never be zero, and will be
+     * aligned for all value types.  Dispose of this memory by calling {@link
+     * #freeMemory}, or resize it with {@link #reallocateMemory}.
+     *
+     * @throws IllegalArgumentException if the size is negative or too large
+     *         for the native size_t type
+     *
+     * @throws OutOfMemoryError if the allocation is refused by the system
+     *
+     * @see #getByte(long)
+     * @see #putByte(long, byte)
+     */
+    public native long allocateMemory(long bytes);
+
+    /**
+     * Resizes a new block of native memory, to the given size in bytes.  The
+     * contents of the new block past the size of the old block are
+     * uninitialized; they will generally be garbage.  The resulting native
+     * pointer will be zero if and only if the requested size is zero.  The
+     * resulting native pointer will be aligned for all value types.  Dispose
+     * of this memory by calling {@link #freeMemory}, or resize it with {@link
+     * #reallocateMemory}.  The address passed to this method may be null, in
+     * which case an allocation will be performed.
+     *
+     * @throws IllegalArgumentException if the size is negative or too large
+     *         for the native size_t type
+     *
+     * @throws OutOfMemoryError if the allocation is refused by the system
+     *
+     * @see #allocateMemory
+     */
+    public native long reallocateMemory(long address, long bytes);
+
+    /**
+     * Sets all bytes in a given block of memory to a fixed value
+     * (usually zero).
+     *
+     * <p>This method determines a block's base address by means of two parameters,
+     * and so it provides (in effect) a <em>double-register</em> addressing mode,
+     * as discussed in {@link #getInt(Object,long)}.  When the object reference is null,
+     * the offset supplies an absolute base address.
+     *
+     * <p>The stores are in coherent (atomic) units of a size determined
+     * by the address and length parameters.  If the effective address and
+     * length are all even modulo 8, the stores take place in 'long' units.
+     * If the effective address and length are (resp.) even modulo 4 or 2,
+     * the stores take place in units of 'int' or 'short'.
+     *
+     * @since 1.7
+     */
+    public native void setMemory(Object o, long offset, long bytes, byte value);
+
+    /**
+     * Sets all bytes in a given block of memory to a fixed value
+     * (usually zero).  This provides a <em>single-register</em> addressing mode,
+     * as discussed in {@link #getInt(Object,long)}.
+     *
+     * <p>Equivalent to <code>setMemory(null, address, bytes, value)</code>.
+     */
+    public void setMemory(long address, long bytes, byte value) {
+        setMemory(null, address, bytes, value);
+    }
+
+    /**
+     * Sets all bytes in a given block of memory to a copy of another
+     * block.
+     *
+     * <p>This method determines each block's base address by means of two parameters,
+     * and so it provides (in effect) a <em>double-register</em> addressing mode,
+     * as discussed in {@link #getInt(Object,long)}.  When the object reference is null,
+     * the offset supplies an absolute base address.
+     *
+     * <p>The transfers are in coherent (atomic) units of a size determined
+     * by the address and length parameters.  If the effective addresses and
+     * length are all even modulo 8, the transfer takes place in 'long' units.
+     * If the effective addresses and length are (resp.) even modulo 4 or 2,
+     * the transfer takes place in units of 'int' or 'short'.
+     *
+     * @since 1.7
+     */
+    public native void copyMemory(Object srcBase, long srcOffset,
+                                  Object destBase, long destOffset,
+                                  long bytes);
+    /**
+     * Sets all bytes in a given block of memory to a copy of another
+     * block.  This provides a <em>single-register</em> addressing mode,
+     * as discussed in {@link #getInt(Object,long)}.
+     *
+     * Equivalent to <code>copyMemory(null, srcAddress, null, destAddress, bytes)</code>.
+     */
+    public void copyMemory(long srcAddress, long destAddress, long bytes) {
+        copyMemory(null, srcAddress, null, destAddress, bytes);
+    }
+
+    /**
+     * Disposes of a block of native memory, as obtained from {@link
+     * #allocateMemory} or {@link #reallocateMemory}.  The address passed to
+     * this method may be null, in which case no action is taken.
+     *
+     * @see #allocateMemory
+     */
+    public native void freeMemory(long address);
+
+    /// random queries
+
+    /**
+     * This constant differs from all results that will ever be returned from
+     * {@link #staticFieldOffset}, {@link #objectFieldOffset},
+     * or {@link #arrayBaseOffset}.
+     */
+    public static final int INVALID_FIELD_OFFSET   = -1;
+
+    /**
+     * Returns the offset of a field, truncated to 32 bits.
+     * This method is implemented as follows:
+     * <blockquote><pre>
+     * public int fieldOffset(Field f) {
+     *     if (Modifier.isStatic(f.getModifiers()))
+     *         return (int) staticFieldOffset(f);
+     *     else
+     *         return (int) objectFieldOffset(f);
+     * }
+     * </pre></blockquote>
+     * @deprecated As of 1.4.1, use {@link #staticFieldOffset} for static
+     * fields and {@link #objectFieldOffset} for non-static fields.
+     */
+    @Deprecated
+    public int fieldOffset(Field f) {
+        if (Modifier.isStatic(f.getModifiers()))
+            return (int) staticFieldOffset(f);
+        else
+            return (int) objectFieldOffset(f);
+    }
+
+    /**
+     * Returns the base address for accessing some static field
+     * in the given class.  This method is implemented as follows:
+     * <blockquote><pre>
+     * public Object staticFieldBase(Class c) {
+     *     Field[] fields = c.getDeclaredFields();
+     *     for (int i = 0; i < fields.length; i++) {
+     *         if (Modifier.isStatic(fields[i].getModifiers())) {
+     *             return staticFieldBase(fields[i]);
+     *         }
+     *     }
+     *     return null;
+     * }
+     * </pre></blockquote>
+     * @deprecated As of 1.4.1, use {@link #staticFieldBase(Field)}
+     * to obtain the base pertaining to a specific {@link Field}.
+     * This method works only for JVMs which store all statics
+     * for a given class in one place.
+     */
+    @Deprecated
+    public Object staticFieldBase(Class<?> c) {
+        Field[] fields = c.getDeclaredFields();
+        for (int i = 0; i < fields.length; i++) {
+            if (Modifier.isStatic(fields[i].getModifiers())) {
+                return staticFieldBase(fields[i]);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Report the location of a given field in the storage allocation of its
+     * class.  Do not expect to perform any sort of arithmetic on this offset;
+     * it is just a cookie which is passed to the unsafe heap memory accessors.
+     *
+     * <p>Any given field will always have the same offset and base, and no
+     * two distinct fields of the same class will ever have the same offset
+     * and base.
+     *
+     * <p>As of 1.4.1, offsets for fields are represented as long values,
+     * although the Sun JVM does not use the most significant 32 bits.
+     * However, JVM implementations which store static fields at absolute
+     * addresses can use long offsets and null base pointers to express
+     * the field locations in a form usable by {@link #getInt(Object,long)}.
+     * Therefore, code which will be ported to such JVMs on 64-bit platforms
+     * must preserve all bits of static field offsets.
+     * @see #getInt(Object, long)
+     */
+    public native long staticFieldOffset(Field f);
+
+    /**
+     * Report the location of a given static field, in conjunction with {@link
+     * #staticFieldBase}.
+     * <p>Do not expect to perform any sort of arithmetic on this offset;
+     * it is just a cookie which is passed to the unsafe heap memory accessors.
+     *
+     * <p>Any given field will always have the same offset, and no two distinct
+     * fields of the same class will ever have the same offset.
+     *
+     * <p>As of 1.4.1, offsets for fields are represented as long values,
+     * although the Sun JVM does not use the most significant 32 bits.
+     * It is hard to imagine a JVM technology which needs more than
+     * a few bits to encode an offset within a non-array object,
+     * However, for consistency with other methods in this class,
+     * this method reports its result as a long value.
+     * @see #getInt(Object, long)
+     */
+    public native long objectFieldOffset(Field f);
+
+    /**
+     * Report the location of a given static field, in conjunction with {@link
+     * #staticFieldOffset}.
+     * <p>Fetch the base "Object", if any, with which static fields of the
+     * given class can be accessed via methods like {@link #getInt(Object,
+     * long)}.  This value may be null.  This value may refer to an object
+     * which is a "cookie", not guaranteed to be a real Object, and it should
+     * not be used in any way except as argument to the get and put routines in
+     * this class.
+     */
+    public native Object staticFieldBase(Field f);
+
+    /**
+     * Detect if the given class may need to be initialized. This is often
+     * needed in conjunction with obtaining the static field base of a
+     * class.
+     * @return false only if a call to {@code ensureClassInitialized} would have no effect
+     */
+    public native boolean shouldBeInitialized(Class<?> c);
+
+    /**
+     * Ensure the given class has been initialized. This is often
+     * needed in conjunction with obtaining the static field base of a
+     * class.
+     */
+    public native void ensureClassInitialized(Class<?> c);
+
+    /**
+     * Report the offset of the first element in the storage allocation of a
+     * given array class.  If {@link #arrayIndexScale} returns a non-zero value
+     * for the same class, you may use that scale factor, together with this
+     * base offset, to form new offsets to access elements of arrays of the
+     * given class.
+     *
+     * @see #getInt(Object, long)
+     * @see #putInt(Object, long, int)
+     */
+    public native int arrayBaseOffset(Class<?> arrayClass);
+
+    /** The value of {@code arrayBaseOffset(boolean[].class)} */
+    public static final int ARRAY_BOOLEAN_BASE_OFFSET
+            = theUnsafe.arrayBaseOffset(boolean[].class);
+
+    /** The value of {@code arrayBaseOffset(byte[].class)} */
+    public static final int ARRAY_BYTE_BASE_OFFSET
+            = theUnsafe.arrayBaseOffset(byte[].class);
+
+    /** The value of {@code arrayBaseOffset(short[].class)} */
+    public static final int ARRAY_SHORT_BASE_OFFSET
+            = theUnsafe.arrayBaseOffset(short[].class);
+
+    /** The value of {@code arrayBaseOffset(char[].class)} */
+    public static final int ARRAY_CHAR_BASE_OFFSET
+            = theUnsafe.arrayBaseOffset(char[].class);
+
+    /** The value of {@code arrayBaseOffset(int[].class)} */
+    public static final int ARRAY_INT_BASE_OFFSET
+            = theUnsafe.arrayBaseOffset(int[].class);
+
+    /** The value of {@code arrayBaseOffset(long[].class)} */
+    public static final int ARRAY_LONG_BASE_OFFSET
+            = theUnsafe.arrayBaseOffset(long[].class);
+
+    /** The value of {@code arrayBaseOffset(float[].class)} */
+    public static final int ARRAY_FLOAT_BASE_OFFSET
+            = theUnsafe.arrayBaseOffset(float[].class);
+
+    /** The value of {@code arrayBaseOffset(double[].class)} */
+    public static final int ARRAY_DOUBLE_BASE_OFFSET
+            = theUnsafe.arrayBaseOffset(double[].class);
+
+    /** The value of {@code arrayBaseOffset(Object[].class)} */
+    public static final int ARRAY_OBJECT_BASE_OFFSET
+            = theUnsafe.arrayBaseOffset(Object[].class);
+
+    /**
+     * Report the scale factor for addressing elements in the storage
+     * allocation of a given array class.  However, arrays of "narrow" types
+     * will generally not work properly with accessors like {@link
+     * #getByte(Object, int)}, so the scale factor for such classes is reported
+     * as zero.
+     *
+     * @see #arrayBaseOffset
+     * @see #getInt(Object, long)
+     * @see #putInt(Object, long, int)
+     */
+    public native int arrayIndexScale(Class<?> arrayClass);
+
+    /** The value of {@code arrayIndexScale(boolean[].class)} */
+    public static final int ARRAY_BOOLEAN_INDEX_SCALE
+            = theUnsafe.arrayIndexScale(boolean[].class);
+
+    /** The value of {@code arrayIndexScale(byte[].class)} */
+    public static final int ARRAY_BYTE_INDEX_SCALE
+            = theUnsafe.arrayIndexScale(byte[].class);
+
+    /** The value of {@code arrayIndexScale(short[].class)} */
+    public static final int ARRAY_SHORT_INDEX_SCALE
+            = theUnsafe.arrayIndexScale(short[].class);
+
+    /** The value of {@code arrayIndexScale(char[].class)} */
+    public static final int ARRAY_CHAR_INDEX_SCALE
+            = theUnsafe.arrayIndexScale(char[].class);
+
+    /** The value of {@code arrayIndexScale(int[].class)} */
+    public static final int ARRAY_INT_INDEX_SCALE
+            = theUnsafe.arrayIndexScale(int[].class);
+
+    /** The value of {@code arrayIndexScale(long[].class)} */
+    public static final int ARRAY_LONG_INDEX_SCALE
+            = theUnsafe.arrayIndexScale(long[].class);
+
+    /** The value of {@code arrayIndexScale(float[].class)} */
+    public static final int ARRAY_FLOAT_INDEX_SCALE
+            = theUnsafe.arrayIndexScale(float[].class);
+
+    /** The value of {@code arrayIndexScale(double[].class)} */
+    public static final int ARRAY_DOUBLE_INDEX_SCALE
+            = theUnsafe.arrayIndexScale(double[].class);
+
+    /** The value of {@code arrayIndexScale(Object[].class)} */
+    public static final int ARRAY_OBJECT_INDEX_SCALE
+            = theUnsafe.arrayIndexScale(Object[].class);
+
+    /**
+     * Report the size in bytes of a native pointer, as stored via {@link
+     * #putAddress}.  This value will be either 4 or 8.  Note that the sizes of
+     * other primitive types (as stored in native memory blocks) is determined
+     * fully by their information content.
+     */
+    public native int addressSize();
+
+    /** The value of {@code addressSize()} */
+    public static final int ADDRESS_SIZE = theUnsafe.addressSize();
+
+    /**
+     * Report the size in bytes of a native memory page (whatever that is).
+     * This value will always be a power of two.
+     */
+    public native int pageSize();
+
+
+    /// random trusted operations from JNI:
+
+    /**
+     * Tell the VM to define a class, without security checks.  By default, the
+     * class loader and protection domain come from the caller's class.
+     */
+    public native Class<?> defineClass(String name, byte[] b, int off, int len,
+                                       ClassLoader loader,
+                                       ProtectionDomain protectionDomain);
+
+    /**
+     * Define a class but do not make it known to the class loader or system dictionary.
+     * <p>
+     * For each CP entry, the corresponding CP patch must either be null or have
+     * the a format that matches its tag:
+     * <ul>
+     * <li>Integer, Long, Float, Double: the corresponding wrapper object type from java.lang
+     * <li>Utf8: a string (must have suitable syntax if used as signature or name)
+     * <li>Class: any java.lang.Class object
+     * <li>String: any object (not just a java.lang.String)
+     * <li>InterfaceMethodRef: (NYI) a method handle to invoke on that call site's arguments
+     * </ul>
+     * @params hostClass context for linkage, access control, protection domain, and class loader
+     * @params data      bytes of a class file
+     * @params cpPatches where non-null entries exist, they replace corresponding CP entries in data
+     */
+    public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);
+
+
+    /** Allocate an instance but do not run any constructor.
+        Initializes the class if it has not yet been. */
+    public native Object allocateInstance(Class<?> cls)
+        throws InstantiationException;
+
+    /** Lock the object.  It must get unlocked via {@link #monitorExit}. */
+    public native void monitorEnter(Object o);
+
+    /**
+     * Unlock the object.  It must have been locked via {@link
+     * #monitorEnter}.
+     */
+    public native void monitorExit(Object o);
+
+    /**
+     * Tries to lock the object.  Returns true or false to indicate
+     * whether the lock succeeded.  If it did, the object must be
+     * unlocked via {@link #monitorExit}.
+     */
+    public native boolean tryMonitorEnter(Object o);
+
+    /** Throw the exception without telling the verifier. */
+    public native void throwException(Throwable ee);
+
+
+    /**
+     * Atomically update Java variable to <tt>x</tt> if it is currently
+     * holding <tt>expected</tt>.
+     * @return <tt>true</tt> if successful
+     */
+    public final native boolean compareAndSwapObject(Object o, long offset,
+                                                     Object expected,
+                                                     Object x);
+
+    /**
+     * Atomically update Java variable to <tt>x</tt> if it is currently
+     * holding <tt>expected</tt>.
+     * @return <tt>true</tt> if successful
+     */
+    public final native boolean compareAndSwapInt(Object o, long offset,
+                                                  int expected,
+                                                  int x);
+
+    /**
+     * Atomically update Java variable to <tt>x</tt> if it is currently
+     * holding <tt>expected</tt>.
+     * @return <tt>true</tt> if successful
+     */
+    public final native boolean compareAndSwapLong(Object o, long offset,
+                                                   long expected,
+                                                   long x);
+
+    /**
+     * Fetches a reference value from a given Java variable, with volatile
+     * load semantics. Otherwise identical to {@link #getObject(Object, long)}
+     */
+    public native Object getObjectVolatile(Object o, long offset);
+
+    /**
+     * Stores a reference value into a given Java variable, with
+     * volatile store semantics. Otherwise identical to {@link #putObject(Object, long, Object)}
+     */
+    public native void    putObjectVolatile(Object o, long offset, Object x);
+
+    /** Volatile version of {@link #getInt(Object, long)}  */
+    public native int     getIntVolatile(Object o, long offset);
+
+    /** Volatile version of {@link #putInt(Object, long, int)}  */
+    public native void    putIntVolatile(Object o, long offset, int x);
+
+    /** Volatile version of {@link #getBoolean(Object, long)}  */
+    public native boolean getBooleanVolatile(Object o, long offset);
+
+    /** Volatile version of {@link #putBoolean(Object, long, boolean)}  */
+    public native void    putBooleanVolatile(Object o, long offset, boolean x);
+
+    /** Volatile version of {@link #getByte(Object, long)}  */
+    public native byte    getByteVolatile(Object o, long offset);
+
+    /** Volatile version of {@link #putByte(Object, long, byte)}  */
+    public native void    putByteVolatile(Object o, long offset, byte x);
+
+    /** Volatile version of {@link #getShort(Object, long)}  */
+    public native short   getShortVolatile(Object o, long offset);
+
+    /** Volatile version of {@link #putShort(Object, long, short)}  */
+    public native void    putShortVolatile(Object o, long offset, short x);
+
+    /** Volatile version of {@link #getChar(Object, long)}  */
+    public native char    getCharVolatile(Object o, long offset);
+
+    /** Volatile version of {@link #putChar(Object, long, char)}  */
+    public native void    putCharVolatile(Object o, long offset, char x);
+
+    /** Volatile version of {@link #getLong(Object, long)}  */
+    public native long    getLongVolatile(Object o, long offset);
+
+    /** Volatile version of {@link #putLong(Object, long, long)}  */
+    public native void    putLongVolatile(Object o, long offset, long x);
+
+    /** Volatile version of {@link #getFloat(Object, long)}  */
+    public native float   getFloatVolatile(Object o, long offset);
+
+    /** Volatile version of {@link #putFloat(Object, long, float)}  */
+    public native void    putFloatVolatile(Object o, long offset, float x);
+
+    /** Volatile version of {@link #getDouble(Object, long)}  */
+    public native double  getDoubleVolatile(Object o, long offset);
+
+    /** Volatile version of {@link #putDouble(Object, long, double)}  */
+    public native void    putDoubleVolatile(Object o, long offset, double x);
+
+    /**
+     * Version of {@link #putObjectVolatile(Object, long, Object)}
+     * that does not guarantee immediate visibility of the store to
+     * other threads. This method is generally only useful if the
+     * underlying field is a Java volatile (or if an array cell, one
+     * that is otherwise only accessed using volatile accesses).
+     */
+    public native void    putOrderedObject(Object o, long offset, Object x);
+
+    /** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)}  */
+    public native void    putOrderedInt(Object o, long offset, int x);
+
+    /** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */
+    public native void    putOrderedLong(Object o, long offset, long x);
+
+    /**
+     * Unblock the given thread blocked on <tt>park</tt>, or, if it is
+     * not blocked, cause the subsequent call to <tt>park</tt> not to
+     * block.  Note: this operation is "unsafe" solely because the
+     * caller must somehow ensure that the thread has not been
+     * destroyed. Nothing special is usually required to ensure this
+     * when called from Java (in which there will ordinarily be a live
+     * reference to the thread) but this is not nearly-automatically
+     * so when calling from native code.
+     * @param thread the thread to unpark.
+     *
+     */
+    public native void unpark(Object thread);
+
+    /**
+     * Block current thread, returning when a balancing
+     * <tt>unpark</tt> occurs, or a balancing <tt>unpark</tt> has
+     * already occurred, or the thread is interrupted, or, if not
+     * absolute and time is not zero, the given time nanoseconds have
+     * elapsed, or if absolute, the given deadline in milliseconds
+     * since Epoch has passed, or spuriously (i.e., returning for no
+     * "reason"). Note: This operation is in the Unsafe class only
+     * because <tt>unpark</tt> is, so it would be strange to place it
+     * elsewhere.
+     */
+    public native void park(boolean isAbsolute, long time);
+
+    /**
+     * Gets the load average in the system run queue assigned
+     * to the available processors averaged over various periods of time.
+     * This method retrieves the given <tt>nelem</tt> samples and
+     * assigns to the elements of the given <tt>loadavg</tt> array.
+     * The system imposes a maximum of 3 samples, representing
+     * averages over the last 1,  5,  and  15 minutes, respectively.
+     *
+     * @params loadavg an array of double of size nelems
+     * @params nelems the number of samples to be retrieved and
+     *         must be 1 to 3.
+     *
+     * @return the number of samples actually retrieved; or -1
+     *         if the load average is unobtainable.
+     */
+    public native int getLoadAverage(double[] loadavg, int nelems);
+
+    // The following contain CAS-based Java implementations used on
+    // platforms not supporting native instructions
+
+    /**
+     * Atomically adds the given value to the current value of a field
+     * or array element within the given object <code>o</code>
+     * at the given <code>offset</code>.
+     *
+     * @param o object/array to update the field/element in
+     * @param offset field/element offset
+     * @param delta the value to add
+     * @return the previous value
+     * @since 1.8
+     */
+    public final int getAndAddInt(Object o, long offset, int delta) {
+        int v;
+        do {
+            v = getIntVolatile(o, offset);
+        } while (!compareAndSwapInt(o, offset, v, v + delta));
+        return v;
+    }
+
+    /**
+     * Atomically adds the given value to the current value of a field
+     * or array element within the given object <code>o</code>
+     * at the given <code>offset</code>.
+     *
+     * @param o object/array to update the field/element in
+     * @param offset field/element offset
+     * @param delta the value to add
+     * @return the previous value
+     * @since 1.8
+     */
+    public final long getAndAddLong(Object o, long offset, long delta) {
+        long v;
+        do {
+            v = getLongVolatile(o, offset);
+        } while (!compareAndSwapLong(o, offset, v, v + delta));
+        return v;
+    }
+
+    /**
+     * Atomically exchanges the given value with the current value of
+     * a field or array element within the given object <code>o</code>
+     * at the given <code>offset</code>.
+     *
+     * @param o object/array to update the field/element in
+     * @param offset field/element offset
+     * @param newValue new value
+     * @return the previous value
+     * @since 1.8
+     */
+    public final int getAndSetInt(Object o, long offset, int newValue) {
+        int v;
+        do {
+            v = getIntVolatile(o, offset);
+        } while (!compareAndSwapInt(o, offset, v, newValue));
+        return v;
+    }
+
+    /**
+     * Atomically exchanges the given value with the current value of
+     * a field or array element within the given object <code>o</code>
+     * at the given <code>offset</code>.
+     *
+     * @param o object/array to update the field/element in
+     * @param offset field/element offset
+     * @param newValue new value
+     * @return the previous value
+     * @since 1.8
+     */
+    public final long getAndSetLong(Object o, long offset, long newValue) {
+        long v;
+        do {
+            v = getLongVolatile(o, offset);
+        } while (!compareAndSwapLong(o, offset, v, newValue));
+        return v;
+    }
+
+    /**
+     * Atomically exchanges the given reference value with the current
+     * reference value of a field or array element within the given
+     * object <code>o</code> at the given <code>offset</code>.
+     *
+     * @param o object/array to update the field/element in
+     * @param offset field/element offset
+     * @param newValue new value
+     * @return the previous value
+     * @since 1.8
+     */
+    public final Object getAndSetObject(Object o, long offset, Object newValue) {
+        Object v;
+        do {
+            v = getObjectVolatile(o, offset);
+        } while (!compareAndSwapObject(o, offset, v, newValue));
+        return v;
+    }
+
+
+    /**
+     * Ensures lack of reordering of loads before the fence
+     * with loads or stores after the fence.
+     * @since 1.8
+     */
+    public native void loadFence();
+
+    /**
+     * Ensures lack of reordering of stores before the fence
+     * with loads or stores after the fence.
+     * @since 1.8
+     */
+    public native void storeFence();
+
+    /**
+     * Ensures lack of reordering of loads or stores before the fence
+     * with loads or stores after the fence.
+     * @since 1.8
+     */
+    public native void fullFence();
+
+    /**
+     * Throws IllegalAccessError; for use by the VM.
+     * @since 1.8
+     */
+    private static void throwIllegalAccessError() {
+       throw new IllegalAccessError();
+    }
+
+}
+~~~
+
+
+
+ 
+
+ 
+
+ 
\ No newline at end of file
diff --git a/week_02/61/unsafe.png b/week_02/61/unsafe.png
new file mode 100644
index 0000000000000000000000000000000000000000..3ee41a0a04f245492882891353876c1939958716
GIT binary patch
literal 1656054
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
Q2s8qXKqJry92o@uAI9kAtpET3

literal 0
HcmV?d00001

-- 
Gitee


From 0093bddbac83df1f804943d841cd295bbc217274 Mon Sep 17 00:00:00 2001
From: Apollo2016926 <944644308@qq.com>
Date: Sat, 21 Dec 2019 22:08:43 +0800
Subject: [PATCH 2/2] step_2

---
 week_02/61/AtomicStampedReference.md |  74 ++++++++++++
 week_02/61/LongAdder.md              | 165 +++++++++++++++++++++++++++
 2 files changed, 239 insertions(+)
 create mode 100644 week_02/61/AtomicStampedReference.md
 create mode 100644 week_02/61/LongAdder.md

diff --git a/week_02/61/AtomicStampedReference.md b/week_02/61/AtomicStampedReference.md
new file mode 100644
index 0000000..b1844d7
--- /dev/null
+++ b/week_02/61/AtomicStampedReference.md
@@ -0,0 +1,74 @@
+# <center>AtomicStampedReference</center>
+
+本文基于jdk1.8
+
+### 简介
+
+AtomicStampedReference是java并发包下提供的一个原子类，它能解决其它原子类无法解决的ABA问题。 
+
+### 源码解析
+
+```java
+// 将值和版本号封装到Pair中 通过比较Pair对象中的renference 和stamp来解决ABA问题
+private static class Pair<T> {
+    final T reference;
+    final int stamp;
+    private Pair(T reference, int stamp) {
+        this.reference = reference;
+        this.stamp = stamp;
+    }
+    static <T> Pair<T> of(T reference, int stamp) {
+        return new Pair<T>(reference, stamp);
+    }
+}
+
+private volatile Pair<V> pair;//多个线程同时修改这个pair要可见。
+
+// 构造方法即显示存储的值和版本号既为Pair对象的两个属性
+ public AtomicStampedReference(V initialRef, int initialStamp) {
+        pair = Pair.of(initialRef, initialStamp);
+    }
+// 传入版本号数组对象 获取当前对象的实际值 无论传入的数组值为何
+//总是会返回当前对象的值并且版本号数组的第一个值为当前对象的版本号
+public V get(int[] stampHolder) {
+        Pair<V> pair = this.pair;
+        stampHolder[0] = pair.stamp;
+        return pair.reference;
+    }
+// 实际调用的还是compareAndSet方法和之前分析UNsafe类相似，应该还是在jdk1..8后才会有实际的区别把
+public boolean weakCompareAndSet(V   expectedReference,
+                                     V   newReference,
+                                     int expectedStamp,
+                                     int newStamp) {
+        return compareAndSet(expectedReference, newReference,
+                             expectedStamp, newStamp);
+    }
+
+public boolean compareAndSet(V   expectedReference,
+                                 V   newReference,
+                                 int expectedStamp,
+                                 int newStamp) {
+        Pair<V> current = pair;
+        return
+            //只有当期望值版本号等于当前值和版本号时 才会执行更新
+            expectedReference == current.reference &&
+            expectedStamp == current.stamp &&
+            //当当前版本和值等于要修改的版本和值时虽然返回true 但实际并未作更新 版本号也不会变化
+            ((newReference == current.reference &&
+              newStamp == current.stamp) ||
+             //反之用新值及版本替换旧值和版本
+             casPair(current, Pair.of(newReference, newStamp)));
+    }
+
+// 当版本号不一致时 new一个新的对将当前对象替换
+ public boolean attemptStamp(V expectedReference, int newStamp) {
+        Pair<V> current = pair;
+        return
+            expectedReference == current.reference &&
+            (newStamp == current.stamp ||
+             casPair(current, Pair.of(expectedReference, newStamp)));
+    }
+
+
+
+```
\ No newline at end of file
diff --git a/week_02/61/LongAdder.md b/week_02/61/LongAdder.md
new file mode 100644
index 0000000..aaa3eae
--- /dev/null
+++ b/week_02/61/LongAdder.md
@@ -0,0 +1,165 @@
+# <center>LongAdder源码分析</center>
+
+本文基于jdk1.8
+
+### 简介
+
+此类部门设计思想是为分而治之，多线程下当竞争不激烈时只更新base的值，当竞争激烈时分段更新最终汇总。
+
+相比AtmoicLong随着线程数增多对性能的影响更小。
+
+### 源码解析
+
+```java
+//其直接父类的静态内部类 
+@sun.misc.Contended //类中的成员变量消除了伪共享
+static final class Cell {
+    volatile long value;//实际存的值
+    Cell(long x) { value = x; }
+    final boolean cas(long cmp, long val) {//cas更新value
+        return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
+    }
+
+    // Unsafe mechanics
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long valueOffset;
+    static {
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> ak = Cell.class;
+            valueOffset = UNSAFE.objectFieldOffset
+                (ak.getDeclaredField("value"));
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+    }
+}
+```
+
+```java
+//将多个cell数组中的值加起来的和就类似于AtomicLong中的value
+public long sum() {
+    Cell[] as = cells; Cell a;
+    long sum = base;
+    if (as != null) {
+        for (int i = 0; i < as.length; ++i) {
+            if ((a = as[i]) != null)
+                sum += a.value;
+        }
+    }
+    return sum;
+}
+
+
+public void add(long x) {
+        Cell[] as; long b, v; int m; Cell a;
+        if ((as = cells) != null || !casBase(b = base, b + x)) {
+            boolean uncontended = true;
+            if (as == null || (m = as.length - 1) < 0 ||
+                (a = as[getProbe() & m]) == null ||
+                !(uncontended = a.cas(v = a.value, v + x)))
+                longAccumulate(x, null, uncontended);
+        }
+    }
+
+//第一次cells数组为空,进入casBase()即原子更新,成功则直接返回,失败则说明出现并发了 if的三个判断
+数组为空
+或者数组长度小于1
+或者位置上没有Cell对象,即getProbe()&m其实相当于hashMap里面的tab[i = (n - 1) & hash]
+或者修改cell的值失败
+才会最终进入到longAccumulate()
+
+   final boolean casBase(long cmp, long val) {
+        return UNSAFE.compareAndSwapLong(this, BASE, cmp, val);
+    }
+
+final void longAccumulate(long x, LongBinaryOperator fn,
+                              boolean wasUncontended) {
+        int h;
+        if ((h = getProbe()) == 0) {
+            ThreadLocalRandom.current(); // force initialization
+            h = getProbe();
+            wasUncontended = true;
+        }
+        boolean collide = false;                // True if last slot nonempty
+        for (;;) {
+            Cell[] as; Cell a; int n; long v;
+            if ((as = cells) != null && (n = as.length) > 0) {
+                if ((a = as[(n - 1) & h]) == null) {
+                    if (cellsBusy == 0) {       // Try to attach new Cell
+                        Cell r = new Cell(x);   // Optimistically create
+                        if (cellsBusy == 0 && casCellsBusy()) {
+                            boolean created = false;
+                            try {               // Recheck under lock
+                                Cell[] rs; int m, j;
+                                if ((rs = cells) != null &&
+                                    (m = rs.length) > 0 &&
+                                    rs[j = (m - 1) & h] == null) {
+                                    rs[j] = r;
+                                    created = true;
+                                }
+                            } finally {
+                                cellsBusy = 0;
+                            }
+                            if (created)
+                                break;
+                            continue;           // Slot is now non-empty
+                        }
+                    }
+                    collide = false;
+                }
+                else if (!wasUncontended)       // CAS already known to fail
+                    wasUncontended = true;      // Continue after rehash
+                else if (a.cas(v = a.value, ((fn == null) ? v + x :
+                                             fn.applyAsLong(v, x))))
+                    break;
+                else if (n >= NCPU || cells != as)
+                    collide = false;            // At max size or stale
+                else if (!collide)
+                    collide = true;
+                else if (cellsBusy == 0 && casCellsBusy()) {
+                    try {
+                        if (cells == as) {      // Expand table unless stale
+                            Cell[] rs = new Cell[n << 1];
+                            for (int i = 0; i < n; ++i)
+                                rs[i] = as[i];
+                            cells = rs;
+                        }
+                    } finally {
+                        cellsBusy = 0;
+                    }
+                    collide = false;
+                    continue;                   // Retry with expanded table
+                }
+                h = advanceProbe(h);
+            }
+            else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
+                boolean init = false;
+                try {                           // Initialize table
+                    if (cells == as) {
+                        Cell[] rs = new Cell[2];
+                        rs[h & 1] = new Cell(x);
+                        cells = rs;
+                        init = true;
+                    }
+                } finally {
+                    cellsBusy = 0;
+                }
+                if (init)
+                    break;
+            }
+            else if (casBase(v = base, ((fn == null) ? v + x :
+                                        fn.applyAsLong(v, x))))
+                break;                          // Fall back on using base
+        }
+    }
+如果Cells表为空，尝试获取锁之后初始化表（初始大小为2）；
+
+如果Cells表非空，对应的Cell为空，自旋锁未被占用，尝试获取锁，添加新的Cell；
+
+如果Cells表非空，找到线程对应的Cell，尝试通过CAS更新该值；
+
+如果Cells表非空，线程对应的Cell CAS更新失败，说明存在竞争，尝试获取自旋锁之后扩容,将cells数组扩大，降低每个cell的并发量后再试
+
+```
+
-- 
Gitee