java多线程（4）内存模型概述

一、java并发编程模型

 在并发编程中，我们需要处理两个关键问题：
 ①线程之间如何通信（线程以何种机制来交换信息）
 ②线程之间如何同步（如何控制线程执行的先后顺序）

在java中采用共享内存模型，线程之间通过读写内存中的公共状态来隐式地进行通信，整个通信过程，对程序员透明；
同步是显示进行的，程序员必须显示的指定某个方法或某段代码需要在线程之间互斥执行。

二、可见性

java堆内存保存实例对象，是线程共享内存。也是共享内存模型的主要工作区域。
可见性：一个线程对共享变量值的修改，能够及时地被其他线程看到。
共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量。

java内存模型（JMM）
java内存模型（java Memory Model）描述了java程序中各种变量（线程共享变量）的访问规则，以及在JVM中将变量存储到内存和从内存中读取出变量这样的底层细节。

①所有变量都存储在主内存中
②每个线程都有自己独立的工作内存，里面保存该线程适用到的变量的副本（主内存中该变量的一份拷贝）

两条规则：
①线程对共享变量的所有操作都必修在自己的内存中进行，不能直接从主内存中读写。
②不同线程之间无法直接访问其他线程工作内存中的变量，线程间变量值的传递需要通过主内存来完成。

共享变量可见性实现的原理
线程1对共享变量的修改要想被线程2及时看到，必须要经过如下两个步骤：

• 把工作内存1中更新过的共享变量刷新到主内存中
• 将主内存中最新的共享变量的值更新到工作内存2中

三、synchronized实现可见性

JMM关于synchronized的两条规定：

• 线程解锁前，必须把共享变量的最新值刷新到主内存中
• 线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时，需要从主内存中重新读取最新的值（加锁与解锁需要是同一把锁）

线程执行互斥代码的过程：

1. 获取互斥锁
2. 清空工作内存
3. 从主内存拷贝变量的最新副本到工作内存
4. 执行代码
5. 将更改后的共享变量的值刷新到主内存
6. 释放互斥锁

重排序：代码书写的顺序与实际执行的顺序不同，指令重排序是编译器或处理器为了提高程序性能而做的优化

1. 编译器优化的重排序（编译器优化）
2. 指令并行重排序（处理器优化）
3. 内存系统的重排序（处理器优化）

as-if-serial：无论如何重排序，程序执行的结果应该与代码顺序执行的结果一直（Java编译器、运行时和处理器都会保证Java在单线程下遵守as-if-serial语义）

例如：

int num1 = 1;
int num2 = 2;
int sum = num1 + num2;

单线程：第1、2行的顺序可以重排，但第3行不能。
重排序不会给单线程带来内存可见性问题。
多线程中程序交错执行时，重排序可能会造成内存可见性问题。

四、synchronize实现可见性代码

public class SynchronizedDemo{
    private boolean ready = false;
    private int result = 0;
    private int number = 1;

    public void write(){
        ready = true;//1.1
        number = 2;//1.2
    }

    public void read(){
        if(ready){//2.1
            result = number * 3;//2.2
        }
        System.out.println("result的结果为："+result);
    }

    //内部线程类
    private class ReadWriteThread extends Thread{
        private boolean flag;
        public ReadWriteThread(boolean flag){
            this.flag = flag;
        } 

        @Override
        public void run(){
            if(flag){
                write();
            }else{
                read();
            }
        }
    }
}

public static void main(String[] args){
    SynchronizedDemo syncDemo = new SynchronizedDemo();
    syncDemo.new ReadWriteThread(true).start();
    syncDemo.new ReadWriteThread(false).start();
}

• 1.1->2.1->2.2->1.2 result:3
• 1.2->2.1->2.2->1.1 result:0 1.1与1.2出现重排序
• 2.1 和 2.2重排序

int mid = number*3;
if(ready){
    result = mid;
}

导致共享变量在线程间不可见的原因：
- 线程的交叉执行
- 重排序结合线程的交叉执行
- 共享变量更新后的值没有在工作内存与主内存间及时更新

五、volatile实现可见性

能够保证volatile变量的可见性
- 不能保证volatile变量复合操作的原子性

volatile如何实现内存可见性：
深入来说：通过加入内存屏障和禁止重排序优化来实现的。
通俗来说：volatile变量在每次被线程访问时，都强迫从主内存中重读该变量的值，而当该变量发生变化时，又会强迫线程将最新的值刷新到主内存。这样任何时刻，不同的线程总能看到该变量最新值。

线程写volatile变量的过程：

1. 改变线程工作内存中volatile变量副本的值
2. 将改变后的副本的值从工作内存刷新到主内存

线程读volatile变量的过程:

1. 从主内存中读取volatile变量的最新值到线程的工作内存中
2. 从工作内存中读取volatile变量的副本

volatile不能保证volatile变量复合操作的原子性：

private int number = 0;
number ++;//不是原子操作，可分为以下三步
//1 读取number的值
//2 将number的值加1
//3 写入最新的number值

//加入synchronized，变为原子操作
synchronized(this){
    number ++;
}

//变为volatile变量，无法保证原子性
private volatile int number = 0;

六、volatile不能保证原子性代码

public class VolatileDemo{
    private volatile int number = 0;
    public int getNumber(){
        return this.number;
    }

    public void increase(){
        this.number++;
    }

    public static void main(String[] args){
        VolatileDemo volDemo = new VolatileDemo();
        for(int i=0;i<500;i++){
            new Thread(new Runnable(){
                @Override
                public void run(){
                    volDemo.increase();
                }
            }).start();

            //如果还有子线程在运行，主线程就让出CUP资源
            //直到所有的子线程都运行完了，主线程再继续往下执行
            while(Thread.activeCount()>1){
                Thread.yield();
            }
            System.out.println("number:"+volDemo.getNumber());
        }
    }
}

多执行几次，发现结果可能不为500；
程序分析：
假如 number = 5；
1.线程A读取number的值；
2.线程B读取number的值；
3.线程B执行加1操作；
4.线程B写入最新的number的值；

此时：线程A工作内存：number = 5；

5.线程A执行加1操作；
6.线程A写入最新的number值；

-----------------------------------------------
保证number自增操作的原子性解决方案：
①使用synchronized关键字
②使用java.util.concurrent.locks包下的ReentrantLock
③使用java.util.concurrent.atomic包下的AtomicInterger

七、synchronized VS volatile

• volatile不需要加锁，比synchronized更轻量级，不会阻塞线程。
• 从内存可见性角度讲，volatile读相当于加锁，volatile写相当于解锁。
• synchronized既能保证原子性，又能保证可见性。而volatile只能保证可见性，无法保证原子性。