（JVM）我们该如何认识 Java的内存模型（Java Memory Model（JMM））? 本篇文章告诉你答案 !带你全面了解JMM

synchronized(对象){
    
}

package JMM;

public class demo1 {
    static int c = 0;
    static Object obj = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                synchronized (obj) {
                    c++;
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                synchronized (obj) {
                    c--;
                }
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(c);
    }
}

/**
 * 可见性
 */
public class demo {
    static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (flag) {
                System.out.println("测试");
            }
        });

        t1.start();

        Thread.sleep(1000);
        flag = false;

    }
}

volatile static boolean flag = true;

package JMM;

/**
 * 有序性
 */
public class demo2 {
    int num = 0;
    boolean ready = false;

    static class Result{
        int num = 0;
    }

    public void actor1(Result r){
        if (ready){
            r.num = num +num;
        }else {
            r.num = 1;
        }
    }

    public void actor2(Result r){
        num = 2;
        ready = true;
    }
}

volatile boolean ready = false;

static int i;
static int j;

// 在某个线程内执行如下赋值操作
i = ...;// 一种较为耗时的操作
j = ...;

final class Singleton{
    private Singleton (){}
    private static Singleton INSTANCE=null;
    public static Singleton getInstance(){
        if (INSTANCE==null){
            synchronized (Singleton.class){
                if (INSTANCE==null){
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

17: new           #3                  // class JMM/demo3
20: dup
21: invokespecial #4                  // Method "<init>":()V
24: putstatic     #2                  // Field INSTANCE:LJMM/demo3;

public class demo4 {
    static int x;
    static  Object m = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (m) {
                x = 10;
            }
        },"t1");
        t1.start();

        new Thread(() -> {
            synchronized (m) {
                System.out.println(x);
            }
        },"t2").start();
    }
}

package JMM;

public class demo5 {
    static int z = 0;

    public static void main(String[] args) {
        while (true) {
            int o = z; // 比如拿到了当前值0
            int n = o+1; // 在旧值 0 的基础上增加 1，正确结果是 1

            /**
             * 这时候如果别的线程把共享变量改成了 5，本线程的正确结果是 1 就作废了，这时候
             * CAS 返回 false，重新尝试，直到：
             * CAS 返回 true，表示我本线程做修改的同时，别的线程没有干扰
             */
            if (CAS(o,n)){
                // 成功，退出循环
                break;
            }
        }
        System.out.println(z);
    }

    private static boolean CAS(int o, int n) {
        z = n;
        if (o == z){
            return true;
        }
        return false;
    }
}

package JMM;

import jdk.internal.misc.Unsafe;
import java.lang.reflect.Field;

public class demo6 {
    public static void main(String[] args) throws InterruptedException {
        DataContainer dc = new DataContainer();
        int count = 5;
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < count; i++) {
                dc.increase();
            }
        });
        t1.start();
        t1.join();
        System.out.println(dc.getData());
    }
}
class DataContainer{
    private volatile int data;
    static Unsafe unsafe = null;
    static long DATA_OFFSET = 0;

    static{
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            unsafe = (Unsafe) theUnsafe.get("null");

        }catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }

        try {
            DATA_OFFSET = unsafe.objectFieldOffset(DataContainer.class.getDeclaredField("data"));
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 相加
     */
    public void increase(){
        int oldValue;
        // 当cas修改成功后，会返回true，那时候会结束循环，否则将一直循环尝试修改
        while(true){
            // 获得共享变量旧值
            oldValue = data;
            // cas 尝试修改data为【旧值 +1】；如果期间旧值被别的线程改了，则返回false
            if (unsafe.compareAndSetInt(this,DATA_OFFSET,oldValue,oldValue+1)){
                return;
            };
        }
    }

    /**
     * 相减
     */
    public void decrease(){
        int oldValue;
        while(true){
            oldValue = data;
            if (unsafe.compareAndSetInt(this,DATA_OFFSET,oldValue,oldValue-1)){
                return;
            };
        }
    }

    public int getData(){
        return data;
    }
}

static Object obj new Object();
public static void method1(){
    synchronized(obj){
        // 同步块A
        method2();
    }
}
public static void method2(){
    synchronized(obj){
		// 同步块B
    }
}

static Object obj = new Object();
public static void method1(){
    synchronized(obj){
        // 同步块
    }
}

new StringBuffer().append("a").append("b").append("c");