课后问题：
对比了Sequence与AtomicLong源码，在于CAS之前，Disruptor直接取原有值，做CAS操作；而AtomicLong使用了getLongVolatile获值。
两者value都用了Volatile来修饰，这点是共同的；但在于获值时，AtomicLong又再次使用volatile(getLongVolatile), 由于Volatile会在内存中强行刷新此值，相比这样就会增加一次性能的消耗，另外还有Spinlock（自旋锁），这两点都会带来性能消耗。
为什么Disruptor可以这样做，免掉getLongVolatile操作，我猜想应该是缓存行的填充，避免了伪共享（False Sharing）的问题，线程对value值的修改，不会出现不同线程同时修改同一缓存行不同变量的问题，所以不需要再次强行刷内存的步骤。

请老师指正！！！

 /** Sequence关于取值是直接Get(), 查看内部方法直接返回value
     *
     * Atomically add the supplied value.
     *
     * @param increment The value to add to the sequence.
     * @return The value after the increment.
     */
    public long addAndGet(final long increment)
    {
        long currentValue;
        long newValue;

        do
        {
            currentValue = get();
            newValue = currentValue + increment;
        }
        while (!compareAndSet(currentValue, newValue));

        return newValue;
    }

/** AtomicLong关于取值时使用getLongVolatile，查看其源码，增加了Volatile和自旋锁
     *
     * getAndAddLong
     *
*/
public final long getAndAddLong(Object var1, long var2, long var4) {
        long var6;
        do {
            var6 = this.getLongVolatile(var1, var2);
        } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));

        return var6;
    }

/** getLongVolatile源码（C++）
   *
   * 1. volatile, 刷新内存
   * 2.Spinlock, 自旋锁
   */
jlong
sun::misc::Unsafe::getLongVolatile (jobject obj, jlong offset)
{
  volatile jlong *addr = (jlong *) ((char *) obj + offset);
  spinlock lock;
  return *addr;
}