18.Java内存模型与线程

硬件的效率与一致性

在计算机中由于处理器与主存之间处理速度存在着数量级的差异，为此计算机引入了一个高速缓存，用于解决该问题。但这样也造成了另一个问题，就是缓存一致性问题。

在多个处理器中，每个处理器都有自己的高速缓存，而他们又共享同一主存。当多个处理器的运算任务都涉及统一块主存区域是，将可能导致各自的缓存数据不一致。

为了解决这个问题，需要各个处理器访问缓存时都遵循一些协议，在读写时，要根据协议来进行操作，这类协议有MSI、MESI、MOSI、Synapse、Firefly及Dragon Protocol等。

主内存与工作内存

Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中奖变量存储到内存和从内存中取出变量这样的底层细节。此处的变量与Java编程中所说的变量有所区别，它包括了实例字段、静态字段和构成数组对象的元素，但不包括局部变量与方法参数，因为后者是线程私有的，不会被共享，自然就不会存在竞争问题。为了获得较好的执行小能，Java内存模型并没有限制执行引擎使用处理器的特定寄存器或缓存来和主存进行交互，也没有限制即时编译器进行调整代码执行顺序这类优化措施。

Java内存模型规定了所有的变量都存储在主内存中（此处的主内存与介绍物理硬件时的主内存名字一样，两者也可以互相类比，但此处仅是虚拟机内存的一部分），线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取，赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量、不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成，线程、主内存三者的交互关系如下：

这里所说的主内存、工作内存与Java内存区域中的Java堆、栈、方法区等不适同一个层次的内存划分，这两者基本上是没有关系的，如果两者一定要勉强对应起来，那从变量、主内存、工作内存的定义来看，主内存主要对应于Java堆中的对象实例数据部分，而工作内存则对应虚拟机栈中的部分区域。从更低层次上说，主内存就直接对应于物理硬件的内存，而为了获取更好的运行速度，虚拟机可能会让工作内存优先存储于寄存器和高速缓存中，因为程序运行时主要访问读写的是工作内存。

内存间交互操作

关于主内存与工作内存之间的具体的交互协议，即一个变量如何从主存拷贝到工作内存、如何从工作内存同步回主存之类的实现细节，Java内存模型中定义了以下8种操作来完成，虚拟机实现实时必须保证下面提及的每一种操作都是原子性、不可再分的。

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

volatile型变量的特殊规则

1. 当一个变量定义为volatile之后，它将具备两种特性，第一是保证次变量对所有线程的可见性，这里的“可见性”是指当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的。而普通变量不能做到这一点，普通变量的值在线程间传递均需要通过主存来完成。
2. volatile并不是线程安全的。demo

        public class VolatileTest {
    public static volatile int race=0;
    public static void increase(){
        race++;
    }
    private static final int THREADS_COUNT=20;
    public static void main(String []args){
        Thread[] threads=new Thread[THREADS_COUNT];
        for(int i=0;i<THREADS_COUNT;i++){
            threads[i]=new Thread(new Runnable(){
                @Override
                public void run(){
                    for(int i=0;i<10000;i++){
                        increase();
                    }
                }

            });
            threads[i].start();
        }
        while (Thread.activeCount()>1){
            Thread.yield();
        }
        System.out.println(race);
    }
}
      

1. volatile可以禁止指令重排序。

        public class Singleton{
        private volatile static Singleton instance;
        public static Singleton getInstance(){
            if(instance==null){
                synchronized(Singleton.class){
                    if(instance==null){
                        instance=new Singleton();
                    }
                }
            }
            return instance;
        }
        public static void main(String[]args){
            Singleton.getInstance();
        }
    }
      

对于long和double型变量的特殊规则

对于64位的数据类型（long和double），在模型中特别定义了一条相对宽松的规定：允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行，即允许虚拟机实现选择可以不保证64位数据类型的load、store、read和write这4个操作的原子性，这点就是所谓的long和double的非原子性协定。

原子性、可见性与有序性

原子性：由Java内存模型来直接保证的原子变量操作包括read、load、assign、use、store和write，我们大致可以认为基本数据类型的访问读写是具备原子性的。

如果应用场景需要一个更大范围的原子性保证,Java内存模型提供了lock和unlock操作来满足这种需求，尽管虚拟机未把lock和unlock操作直接开放给用户使用，但却提供了更高层次的字节码指令monitorenter和monitorexit来隐式地使用这两个操作，这两个字节码指令反映到Java代码中就是同步块--synchronized关键字。

可见性：可见性是指当一个线程修改了共享变量的值，其他编程能够理解得知这个修改。除了volatile之外，Java还有两个关键字能实现可见性，即synchronized和final。synchronized是有“对一个变量执行unlock操作之前，必须先把此变量同步会主存中”，而final是指：被final修饰的字段在构造器中一旦被初始化完成，并且构造器没有把“this”的引用传递出去，那在其他线程中就能看见final字段的值。

有序性：Java程序中天然的有序性可以总结为一句话：如果在本线程内观察，所有的操作都是有序的;如果在一个线程中观察另一个线程，所有的操作都是无需的。