SAE又允许JVM内存对象直接读写操作

/*
  * %W% %E%
  *
  * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  */
 
 package java.util.concurrent.atomic;
 import sun.misc.Unsafe;
 
 /**
  * A  long} value that may be updated atomically.  See the
  *  java.util.concurrent.atomic} package specification for
  * description of the properties of atomic variables. An
  *  AtomicLong} is used in applications such as atomically
  * incremented sequence numbers, and cannot be used as a replacement
  * for a  java.lang.Long}. However, this class does extend
  *  Number} to allow uniform access by tools and utilities that
  * deal with numerically-based classes.
  *
  * @since 1.5
  * @author Doug Lea
  */
 public class AtomicLong extends Number implements java.io.Serializable {
     private static final long serialVersionUID = 1927816293512124184L;
 
     // setup to use Unsafe.compareAndSwapLong for updates
     private static final Unsafe unsafe = Unsafe.getUnsafe();
     private static final long valueOffset;
 
     /**
      * Records whether the underlying JVM supports lockless
      * CompareAndSet for longs. While the unsafe.CompareAndSetLong
      * method works in either case, some constructions should be
      * handled at Java level to avoid locking user-visible locks.
      */
     static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
 
     /**
      * Returns whether underlying JVM supports lockless CompareAndSet
      * for longs. Called only once and cached in VM_SUPPORTS_LONG_CAS.
      */
     private static native boolean VMSupportsCS8();
 
     static {
       try {
         valueOffset = unsafe.objectFieldOffset
             (AtomicLong.class.getDeclaredField("value"));
       } catch (Exception ex) { throw new Error(ex); }
     }
 
     private volatile long value;
 
     /**
      * Creates a new AtomicLong with the given initial value.
      *
      * @param initialValue the initial value
      */
     public AtomicLong(long initialValue) {
         value = initialValue;
     }
 
     /**
      * Creates a new AtomicLong with initial value  0}.
      */
     public AtomicLong() {
     }
 
     /**
      * Gets the current value.
      *
      * @return the current value
      */
     public final long get() {
         return value;
     }
 
     /**
      * Sets to the given value.
      *
      * @param newValue the new value
      */
     public final void set(long newValue) {
         value = newValue;
     }
 
     /**
      * Eventually sets to the given value.
      *
      * @param newValue the new value
      * @since 1.6
      */
     public final void lazySet(long newValue) {
         unsafe.putOrderedLong(this, valueOffset, newValue);
     }
 
     /**
      * Atomically sets to the given value and returns the old value.
      *
      * @param newValue the new value
      * @return the previous value
      */
     public final long getAndSet(long newValue) {
         while (true) {
             long current = get();
             if (compareAndSet(current, newValue))
                 return current;
         }
     }
 
     /**
      * Atomically sets the value to the given updated value
      * if the current value  ==} the expected value.
      *
      * @param expect the expected value
      * @param update the new value
      * @return true if successful. False return indicates that
      * the actual value was not equal to the expected value.
      */
     public final boolean compareAndSet(long expect, long update) {
  return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
     }
 
     /**
      * Atomically sets the value to the given updated value
      * if the current value  ==} the expected value.
      *
      * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
      * and does not provide ordering guarantees, so is only rarely an
      * appropriate alternative to  compareAndSet}.
      *
      * @param expect the expected value
      * @param update the new value
      * @return true if successful.
      */
     public final boolean weakCompareAndSet(long expect, long update) {
  return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
     }
 
     /**
      * Atomically increments by one the current value.
      *
      * @return the previous value
      */
     public final long getAndIncrement() {
         while (true) {
             long current = get();
             long next = current + 1;
             if (compareAndSet(current, next))
                 return current;
         }
     }
 
     /**
      * Atomically decrements by one the current value.
      *
      * @return the previous value
      */
     public final long getAndDecrement() {
         while (true) {
             long current = get();
             long next = current - 1;
             if (compareAndSet(current, next))
                 return current;
         }
     }
 
     /**
      * Atomically adds the given value to the current value.
      *
      * @param delta the value to add
      * @return the previous value
      */
     public final long getAndAdd(long delta) {
         while (true) {
             long current = get();
             long next = current + delta;
             if (compareAndSet(current, next))
                 return current;
         }
     }
 
     /**
      * Atomically increments by one the current value.
      *
      * @return the updated value
      */
     public final long incrementAndGet() {
         for (;;) {
             long current = get();
             long next = current + 1;
             if (compareAndSet(current, next))
                 return next;
         }
     }
 
     /**
      * Atomically decrements by one the current value.
      *
      * @return the updated value
      */
     public final long decrementAndGet() {
         for (;;) {
             long current = get();
             long next = current - 1;
             if (compareAndSet(current, next))
                 return next;
         }
     }
 
     /**
      * Atomically adds the given value to the current value.
      *
      * @param delta the value to add
      * @return the updated value
      */
     public final long addAndGet(long delta) {
         for (;;) {
             long current = get();
             long next = current + delta;
             if (compareAndSet(current, next))
                 return next;
         }
     }
 
     /**
      * Returns the String representation of the current value.
      * @return the String representation of the current value.
      */
     public String toString() {
         return Long.toString(get());
     }
 
 
     public int intValue() {
  return (int)get();
     }
 
     public long longValue() {
  return (long)get();
     }
 
     public float floatValue() {
  return (float)get();
     }
 
     public double doubleValue() {
  return (double)get();
     }
 
 }

private static final Unsafe unsafe = Unsafe.getUnsafe();

Field field =java.util.concurrent.atomic.AtomicLong.class.getDeclaredField("unsafe");
   field.setAccessible(true);
   sun.misc.Unsafe unsafe = (sun.misc.Unsafe) field.get(null);

默认jdk沙盒是有限制的,属性访问权限限制(前例是包访问限制),SAE这次又漏掉了...