多线程内存可见性

Posted 2020-08-09 Evil_XJZ

一、细说Java多线程之内存可见性（数据挣用）

        1、共享变量在线程间的可见性

               共享变量：如果一个变量在多个线程的工作内存中都存在副本，

                        那么这个变量就是这几个线程的共享变量

               可见性：一个线程对共享变量值的修改，能够及时的被其他线程看到

               Java内存模型（JMM，Java Memory Model）：

                     描述了java程序中各种变量（线程共享变量）的访问规则，以及在JVM中将

                     变量存储到内存和从内存中读取出变量这样的底层细节。

                     所有的变量都存储在主内存中

                     每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的副本

                     （主内存中该变量的一份拷贝）

                     

                      两条规定：    

                           线程对共享变量的所有操作都必须在自己的工作内存（working memory,是cache和寄存器的一个抽象，而并不是内存中的某个部分，这个解释源于《Concurrent Programming in Java: Design Principles and Patterns, Second Edition》§2.2.7，原文：Every thread is defined to have a working memory (an abstraction of caches and registers) in which to store values. 有不少人觉得working memory是内存的某个部分，这可能是有些译作将working memory译为工作内存的缘故，为避免混淆，这里称其为工作存储，每个线程都有自己的工作存储）中进行，不能直接从相互内存中读写

                         不同线程之间无法直接访问其他线程工作内存中的变量，

                         线程间变量值得传递需要通过主内存来完成

                     共享变量可见性的实现原理

                         把工作内存1中更新过的共享变量刷新到主内存中

                         将主内存中最新的共享变量的值更新到工作内存2中

                     Java语言层面支持的可见性实现方式：

                         synchronized

                         volatile

                         final也可以保证内存可见性

        2、synchronized实现可见性

               可以实现互斥锁（原子性），即同步。但很多人都忽略其内存可见性这一特性

               JMM关于synchronized的两条规定：

                   线程解锁前，必须把共享变量的最新值刷新到主内存中

                   线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从内存中重新读取最新的值（注意：加锁与解锁需要是同一把锁）

                   线程解锁前对共享变量的修改在下棋甲所示对其他线程可见

               ·导致共享变量在线程间不可见的原因：

                      1.线程的交叉执行（保证原子性，使用synchronized关键字）

                      2.重排序结合线程交叉执行（原子性）

                      3.共享变量更新后的值没有在工作内存与主内存间及时更新（可见性）

               在Java运行过程中，执行引擎会尽量揣摩用户的意图，所以很多时候都会看到正确的结果，但是哪怕只有一次不可预期的结果出现影响也是非常大的，所以，在需要内存可见性的时候，我们一定要保证线程的安全

        3、volatile实现可见性

              ·指令重排序

                    代码书写的顺序与实际执行的顺序不同，指令冲排序是编译器或处理器

                    为了提高程序性能而做的优化

                       1.编译器优化的重排序（编译器优化）

                       2.指令级并行重排序（处理器优化）

                       3.内存系统的重排序（处理器优化）

                    重排序不会给单线程带来内存可见性的问题（因为as-if-serial语义）

                    多线程中程序交错执行时，重排序可能会造成内存可见性问题

              ·as-if-serial语义

                     无论怎样重排序，程序执行的结果应该玉带啊顺序执行的结果一致（Java

                   编译器、运行时和处理器都会保证Java在单线程下遵循as-if-serial语义）

              

              ·volatile关键字使用注意事项

                   1.能够保证volatile变量的可见性(原理与synchronized关键字原理差不多)

                        深入来说，通过加入内存屏障和禁止重排序优化来实现内存可见性。当对volatile变量执行写操作时，会在写操作后加入一条store屏障指令；当对volatile变量执行读操作时，会在读操作前加入一条load屏障指令

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

                         int num = 0;

                         num++;//++操作非原子操作，分3步执行

                         保证原子性的方法：

                              synchronized关键字

                              ReentrantLock可传入锁对象

                              AtomicInterger对象

                    3.volatile适用场合

                       在多线程中安全的使用volatile变量必须同时满足两个条件：

                       ①对变量的写入操作不依赖其当前值，如number++不可以，

                                                          boolean变量可以

                       ②该变量没有包含在具有其他变量的不变式中，如果有多个

                volatile变量，则每个volatile变量必须独立于其他的volatile变量

        4、synchronized和volatile比较

               volatile不需要加锁，比synchronized更轻量级，不会阻塞线程，效率更高

               从内存可见性角度讲，volatile读相当于加锁，volatile写相当于解锁

               synchronized技能保证可见性，又能保证原子性，而volatile只能保证可见性，不能保证原子性。

               如果能用volatile解决问题，还是应尽量使用volatile，因为它的效率更高 

      一个需要注意的点：

          问：即使没有保证可见性的措施，很多时候共享变量一人能够在主内存和工作内存见得到及时的更新？

          答：一般只有在短时间内高并发的情况下才会出现变量得不到及时更新的情况，因为CPU在执行时会很快的刷新缓存，所以一般情况下很难看到这种问题，而且也与硬件性能有很大的关系，所以，结果都是不可预测的，正式因为不可预测，所以我们才要保证线程的安全问题

          另：java中long、double是64位的，其读写会分成两次32位的操作，并不是原子操作，但很多商用虚拟机都进行了优化，所以，了解即可