java内存模型与多线程

现代计算机，cpu在计算的时候，并不总是从内存读取数据，它的数据读取顺序优先级是：寄存器-高速缓存-内存，线程计算的时候，原始的数据来自内存，在计算过程中，有些数据可能被频繁读取，这些数据被存储在寄存器和高速缓存中，当线程计算完后，这些缓存的数据在适当的时候应该写回内存，当多个线程同时读写某个内存数据时，由于涉及数据的可见性、操作的有序性，所以就会产生多线程并发问题。

Java作为平台无关性语言，JLS(Java语言规范)定义了一个统一的内存管理模型JMM(Java Memory Model)，JMM屏蔽了底层平台内存管理细节，在多线程环境中必须解决可见性和有序性的问题。JMM规定了jvm有主内存(Main Memory)和工作内存(Working Memory) ，主内存存放程序中所有的类实例、静态数据等变量，是多个线程共享的，而工作内存存放的是该线程从主内存中拷贝过来的变量以及访问方法所取得的局部变量，是每个线程私有的其他线程不能访问，每个线程对变量的操作都是以先从主内存将其拷贝到工作内存再对其进行操作的方式进行，多个线程之间不能直接互相传递数据通信，只能通过共享变量来进行。

JLS定义了线程对主存的操作指令：read，load，use，assign，store，write。这些行为是不可分解的原子操作，在使用上相互依赖，read-load从主内存复制变量到当前工作内存，use-assign执行代码改变共享变量值，store-write用工作内存数据刷新主存相关内容。

线程要引用某变量，如果线程工作内存中没有该个变量，通过read-load从主内存中拷贝一个副本到工作内存中，完成后线程会引用该副本，当同一个线程再次引用该变量时，有可能重新从主存中获取变量副本(read-load-use)，也有可能直接引用原来的副本(use)，也就是说read、 load、use顺序可以由jvm实现系统决定。

线程要写入某变量，它会将值指定给工作内存中的变量副本(assign)，完成后这个变量副本会同步到主存(store-write)，至于何时同步过去，即assign,store,write顺序由jvm实现系统决定。

多线程对主存的有序性操作有可能会导致并发问题，看一个例子：

public class Test{
    public int i = 0;
    public void add(){
        i++;
    }
}

前提：线程a、b使用类Test的同一个实例,执行顺序1-6

线程a从主存读取i副本x到工作内存，工作内存中x值为0
线程b从主存读取i副本y到工作内存，工作内存中y值为0
线程a将工作内存中x加1，工作内存中x值变为1
线程a将x提交到主存，主存中i变为1
线程b将工作内存中y加1，工作内存中y值变为1
线程b将y提交到主存中，主存中i变为1

*单线程环境下，i进行两次加1，结果必定是2，但多线程环境下，i进行两次加1，结果不一定是2，这取决于上例中第2和第4步的执行顺序！

volatile是java提供的一种同步手段，只不过它是轻量级的同步，为什么这么说，因为volatile只能保证多线程的内存可见性，不能保证多线程的执行有序性。而最彻底的同步要保证有序性和可见性。当同一线程多次重复对字段赋值时，线程有可能只对工作内存中的副本进行赋值，直到最后一次赋值后才同步到主存储区。任何被volatile修饰的变量，都不拷贝副本到工作内存，任何修改都及时写在主存。因此对于valatile修饰的变量的修改，所有线程马上就能看到，但是volatile不能保证对变量的修改是有序的。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件:

1、对变量的写操作不依赖于当前值。

2、该变量没有包含在具有其他变量的不变式中。

错误的例子:

public class VolatileFalse{   
    public volatile int i;
    public void add(){
        i++;
    }
}

说明：虽然volatile 保证对i的修改“及时”写在主存，所有线程马上能看到，但i = i + 1 对变量i的写操作依赖于当前值，而当前值是可变的，由于多线程下读写i的值是无序的，所以多个线程运行VolatileFalse的同一个实例后的到i的最终值不一定是正确。

正确的例子:

public class VolatileTrue{
    public volatile int i;
    public void setI(int j){
        this.i = j;
    }
}

说明：没有volatie声明，在多线程环境下，i的值不一定是正确的，因为this.i = j;涉及给i赋值和将i的值同步主存的步骤，这个顺序可能被打乱。如果用volatie声明了，读取主存副本到工作内存和同步i到主存的步骤，相当于是一个原子操作，因此是线程安全的。

volatile适合这种场景：一个变量被多个线程共享，线程直接给这个变量赋值。这是一种很简单的同步场景，这时候使用volatile的开销将会非常小。

synchronized关键字作为多线程并发环境的执行有序性的保证手段之一，如果某个线程访问一个标识为synchronized的方法，并对相应变量做操作，那么根据JLS，JVM的执行步骤如下：

取得该对象锁(普通方法的锁为this对象，静态方法则为该类的class对象)并将其锁住(lock)。
将需要的数据从主内存拷贝到自己的工作内存(read and load)。
根据程序流程读取或者修改相应变量值(use and assign)。
将自己工作内存中修改了值的变量拷贝回主内存(store and write)。
释放对象锁(unlock)。

对synchronized的一些总结：

public class Test{
    public void method0(){...} 
    public synchronized void method1(){...} 
    public void method2() { 
        synchronized (this){...}
    }
    public void method3(SomeObject so) { 
 　　   synchronized(so) {...}
    } 
    public void method4() { 
 　　   ...
 　　   private byte[] lock = new byte[0]; 
 　　   synchronized (lock){...} 
 　　   ...
    }
    public synchronized static void method5(){...}
    public void method6(){
        synchronized(Test.class){...}
    } 
}

method1同步函数和method2中同步块synchronized (this){...}所取得的同步锁都是类Test的实例对象，即对象锁，所以method1和method2效果等同。
当多个并发线程访问"同一个"对象中的同步函数或同步块时，取得对象锁的线程得到执行，该线程执行期间，其他要访问该对象同步函数或同步块(不管是不是相同的同步函数或同步块)的线程将会阻塞，直到获取该对象锁后才能执行，当然要访问该对象的非同步方法或同步块的线程不受对象锁的限制，可以直接访问。
method2同步块synchronized (this){...}中this是指调用这个方法的对象，如果两个线程中分别调用的是t1和t2(类Test的实例化)两个对象，则这个同步块对于这两个线程来说无效，这时可以使用method3中同步块synchronized(so) {...}方式，将锁挂在其他对象上面。
如果要对函数中的部分代码进行同步处理，怎么办？method4中通过一个特别的实例变量充当锁来实现。
method5静态同步函数和method6中同步块synchronized(Test.class){...}所取得的同步锁是类锁，即类Test的锁，而非类Test的对象锁。
因为类锁跟对象锁是不同的锁，所以在多线程并发环境下method1和method5不构成同步。

来源：https://www.cnblogs.com/xiongjianjunjava/p/4316117.html

标签

多线程

synchronized

volatile

线程

线程阻塞

变量