Java并发编程——内存模型(JMM)+volatile

一、JMM

JMM：Java内存模型。
JMM规定了内存主要划分为主内存和工作内存两种。主内存对应的是Java堆中的对象实例部分，工作内存对应的是栈中的部分区域。每条线程拥有各自的工作内存，工作内存中的变量是主内存中的一份拷贝。
关于JMM的一些同步的约定
1.线程解锁前，必须把共享变量立刻刷回主存。
2.线程加锁前，必须读取主存中的最新值到工作内存中
3.加锁和解锁是同一把锁

8种操作

1、lock(锁定)：作用于主内存的变量，它把一个变量标识为一条线程独占的状态。
2、unlock(解锁):作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量 才可以被其他线程锁定。
3、read(读取):作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以 便随后的load动作使用。
4、load(载入):作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的 变量副本中。
5、use(使用):作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚 拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
6、assign(赋值):作用于工作内存的变量，它把一个从执行引擎接收的值赋给工作内存的变量， 每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
7、store(存储):作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随 后的write操作使用。
8、write(写入):作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。

同步规则
1.不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write；

2.不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存；

3.不允许一个线程将没有assign的数据从工作内存同步回主内存；

4.一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作；

5.一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁；

6.如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值；

7.如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量；

8.对一个变量进行unlock操作之前，必须把此变量同步回主内存。

二、volatile

1.volatile保证可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
测试代码

public class JMMDemo {
    private static int num=0;
    public static void main(String[] args) throws InterruptedException {//main
        new Thread(()->{//线程1
            while (num==0) {

            }
        }).start();
        TimeUnit.SECONDS.sleep(1);
        num=1;
        System.out.println(num);
    }
}

线程1不知道主线程把num变成了1，所以还在一直执行。因为JMM是不可见的。
修改方式：将num用volatile修饰
private volatile static int num=0;

2.volatile不保证原子性

原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

//volatile不保证原子性
public class Demo02 {
    private volatile static int num=0;
    public static void add(){
        num++;
    }

    public static void main(String[] args) {
        //理论上num=20000
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    add();
                }
            }).start();
        }
        while(Thread.activeCount()>2){//main gc
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

所以volatile不保证原子性，如果要修改则用synchronized修饰add方法，或使用原子类！

public class Demo02 {
    //原子类的Integer
    private volatile static AtomicInteger num=new AtomicInteger();
    public static void add(){
        //num++;//不是原子性操作
        num.getAndIncrement();//AtomicInteger +1 的方法,CAS
    }

    public static void main(String[] args) {
        //理论上num=20000
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    add();
                }
            }).start();
        }
        while(Thread.activeCount()>2){//main gc
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

Atomic这些类的底层都直接和操作系统挂钩！在内存中修改值！Unsafe类是一个很特殊的存在。

3.volatile禁止指令重排

指令重排：你写的程序，计算机并不是按照你的那样去执行的。
源代码——>编译器优化的重排——>指令并行也可能重排——>内存系统也会重排——>执行
处理器在进行指令重排的时候，会考虑数据之间的依赖性

int x = 1;//1
int y = 2;//2
x = x + 5;//3
y = x * x;//4

我们所期望的：1，2，3，4

可能造成影响的结果：
a，b，x，y默认都是0

线程A	线程B
x=a	y=b
b=1	a=2

正常的结果：x = 0 ; y = 0;

线程A	线程B
b=1	a=2
x=a	y=b

指令重排导致的诡异结果：x = 2 ; y = 1

volatile可以避免指令重排：
内存屏障，CPU指令。作用：
1.保证特定的操作的执行顺序
2.可以保证某些变量的内存可见性(利用这些特性，volatile实现了可见性)

用的最多的地方：单例模式！！！