6.volatile与JMM

//....code segment...
public native void loadFence();

public native void storeFence();

public native void fullFence();

     /**
     * 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();

UNSAFE_ENTRY(void, Unsafe_LoadFence(JNIEnv *env, jobject unsafe))
  UnsafeWrapper("Unsafe_LoadFence");
  OrderAccess::acquire();
UNSAFE_END

UNSAFE_ENTRY(void, Unsafe_StoreFence(JNIEnv *env, jobject unsafe))
  UnsafeWrapper("Unsafe_StoreFence");
  OrderAccess::release();
UNSAFE_END

UNSAFE_ENTRY(void, Unsafe_FullFence(JNIEnv *env, jobject unsafe))
  UnsafeWrapper("Unsafe_FullFence");
  OrderAccess::fence();
UNSAFE_END

//声明四类屏障类型,读读,写写,读写,写读
class OrderAccess : AllStatic {
 public:
  static void     loadload();
  static void     storestore();
  static void     loadstore();
  static void     storeload();

    //....more code.....
}

#include "runtime/atomic.inline.hpp"
#include "runtime/orderAccess.hpp"
#include "runtime/os.hpp"
#include "vm_version_x86.hpp"

// Implementation of class OrderAccess.

inline void OrderAccess::loadload()   { acquire(); }
inline void OrderAccess::storestore() { release(); }
inline void OrderAccess::loadstore()  { acquire(); }
inline void OrderAccess::storeload()  { fence(); }

inline void OrderAccess::acquire() {
  volatile intptr_t local_dummy;
#ifdef AMD64
  __asm__ volatile ("movq 0(%%rsp), %0" : "=r" (local_dummy) : : "memory");
#else
  __asm__ volatile ("movl 0(%%esp),%0" : "=r" (local_dummy) : : "memory");
#endif // AMD64
}

inline void OrderAccess::release() {
  // Avoid hitting the same cache-line from
  // different threads.
  volatile jint local_dummy = 0;
}

inline void OrderAccess::fence() {
  if (os::is_MP()) {
    // always use locked addl since mfence is sometimes expensive
#ifdef AMD64
    __asm__ volatile ("lock; addl $0,0(%%rsp)" : : : "cc", "memory");
#else
    __asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", "memory");
#endif
  }
}

    static boolean flag = true;
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t -----come in");
            while (flag) {

            }
            System.out.println(Thread.currentThread().getName() + "\t -----flag被设置为false，程序停止");
        }, "t1").start();

        //暂停几秒钟线程
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        flag = false;

        System.out.println(Thread.currentThread().getName() + "\t 修改完成flag: " + flag);
    }

class MyNumber {
    int number;
    public synchronized void addPlusPlus() {
        number++;
    }
}

    public static void main(String[] args) {
        MyNumber myNumber = new MyNumber();

        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    myNumber.addPlusPlus();
                }
            }, String.valueOf(i)).start();
        }

        //暂停几秒钟线程
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(myNumber.number);

    }

    //volatile变量的复合操作不具备原子性
    volatile int number; 
    public void addPlusPlus() {
        number++;
    }

    /**
     * 使用 : 当读多于写,结合使用内部锁和volatile变量来减少同步的开销
     * 理由 : 利用volatile保证读取操作的可见性,利用synchronized保证复合操作的原子性
     */
    private volatile int value;

    public int getValue() {
        return value; //利用volatile保证读取操作的可见性
    }

    public synchronized int increment() {
        return this.value++; //利用synchronized保证复合操作的原子性
    }

public class SafeDoubleCheckSingleton {
    private static SafeDoubleCheckSingleton safeDoubleCheckSingleton;
    /**
     * 私有构造方法
     */
    private SafeDoubleCheckSingleton() {
    }
    /**
     * 双重锁设计
     */
    public static SafeDoubleCheckSingleton getInstance(){
        if (safeDoubleCheckSingleton==null) {
            synchronized (SafeDoubleCheckSingleton.class){
                if (safeDoubleCheckSingleton==null){
                    //存在隐患==>多线程环境下,由于重排序,该对象可能未完成初始化,就被其它线程所读取
                    safeDoubleCheckSingleton = new SafeDoubleCheckSingleton();
                }
            }
        }
        //对象不为空,已存在或是创建完毕,执行getInstance不需要获取锁,直接返回对象
        return safeDoubleCheckSingleton;
    }
}

memory = allcate();		//1.分配对象内存空间
ctorInstance(memory);	//2.初始化对象
instance = memory;		//3.设置instance指向所分配的内存地址

memory = allcate();		//1.分配对象内存空间
instance = memory;		//3.设置instance指向所分配的内存地址
                        //此时对象还未进行初始化
ctorInstance(memory);	//2.初始化对象

 //通过volatile 声明实现线程安全的延迟初始化
    private volatile static SafeDoubleCheckSingleton safeDoubleCheckSingleton;
    /**
     * 私有构造方法
     */
    private SafeDoubleCheckSingleton() {
    }
    /**
     * 双重锁设计
     */
    public static SafeDoubleCheckSingleton getInstance(){
        //首次检查
        if (safeDoubleCheckSingleton==null) {
            synchronized (SafeDoubleCheckSingleton.class){
                //第二次检查
                if (safeDoubleCheckSingleton==null){
                    //存在隐患==>多线程环境下,由于重排序,该对象可能未完成初始化,就被其它线程所读取
                    safeDoubleCheckSingleton = new SafeDoubleCheckSingleton();
                    //解决隐患的原理: 利用volatile,禁止"初始化对象"(2)和"设置singleton指向内存空间"(3)的重排序
                }
            }
        }
        //对象不为空,已存在或是创建完毕,执行getInstance不需要获取锁,直接返回对象
        return safeDoubleCheckSingleton;
    }