细说java多线程之内存可见性

课程名称： 细说java多线程之内存可见性
课程地址：https://www.imooc.com/learn/352
课程评价：内容讲的一般吧，讲的知识体系不够完善，还有些讲错了。不怎么适合新手，老手也就图个检验所学知识。

第2章 2-1 可见性介绍

课程内容

什么是可见性

jmm内存模型

jmm内存模型

工作内存和主内存

线程数据读写规定

如何保证可见性？

可见性实现原理

可见性的实现方式

图片.png

第3章 synchronized实现可见性

synchronized实现可见性

synchronized为什么可以实现可见性？

sychronized实现可见性的过程

互斥

这个讲师讲解大致的流程没错，但是概念上有多个地方是不对的。工作内存中值的清除并没有进行清除操作，而是cpu只是简单标注为失效，并且这个失效标注的动作，是在解锁的时候发生的，加锁的时候如果发现这个值失效，会从主内存重新读一次，所以讲师要注意，不要误导广大网友。

三种重排序

重排序

as-if-serial

不管怎么重排序(编译器和处理器为了提高并行度),(单线程)程序的执行结果不能被改变。

java内存中的变量都有指针引用，上下文引用成链，这个链是不会被打乱重排序的，只有没有数据依赖关系的代码，才会被冲排序，所以在单线程内部重排序不会改变程序运行结果，这就是as-if-serial

单线程遵守as-if-serial

多线程发生可见性问题

多线程发生可见性问题

图片.png

大大的疑惑？

2.1和2.2间没有数据依赖关系？（好像没有）所以因为没有数据依赖关系，所以真的会存在这种重排序吗？
这样cpu不得多执行计算出mid变量，有时还用不上这个mid变量。

可见性问题分析

可见性分析

volatile

volatile的特性

volatile的特性)

volatile实现可见性的原理

• 这里提到插入一条sotre的屏障指令和一条load屏障指令，但是其实不够完善，volatile变量的读写前面也可能会加屏障指令。

  
  
  volatile的原理

源码分析不能保证原子性

原子性

volatile无法保证原子性

  void readAndWrite();
    descriptor: ()V
    flags:
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: dup
         2: getfield      #4                  // Field a:I
         5: iconst_1            #iconst_1指令将number的值5压入栈后，cpu资源释放，此时即使number的值在工作内存失效，也不会导致 iadd重新从主内存获取6的值再进行 + 1 
         6: iadd
         7: putfield      #4                  // Field a:I
        10: return
      LineNumberTable:
        line 20: 0
        line 21: 10
}
SourceFile: "Test.java"

解决原子性问题方案

解决方案

适用场景

synchronized和volatile的比较

从内存可见性角度讲，volatile读相当于加锁（volatile读时，前面的操作加了内存屏障，且对该volatile共享变量的写操作，它对volatile读是可见的，所以这些操作都跟synchronized加锁一样），volatile写相当于解锁（volatile写时，也会加入内存屏障，防止后面的操作跟volatile进行重排序等，对volatile写时，会强制刷新到主内存中，这跟synchronized解锁一样，解锁前需要把共享变量刷新到主内存中去，确保了可见性）

课程总结

• java语言层面有三种：synchronized，volatile，final

可见性

图片.png

double和long的读写非原子性

这是因为jvm的规范并没有要求64位的long或者double的写入是原子性的。在32位的机器上，一个64位变量的写入可能被拆分成两个32位的写操作来执行，这样如果只写入32位，而cpu释放，那么读取的线程就会只读到“”一半的值”。

volatile本身不保证获取和设置操作的原子性，仅仅保持修改的可见性。但是java的内存模型保证声明为volatile的long和double变量的get和set操作是原子的。转自慕课问答，楼下有疑惑的亲们看一下吧~~~

package mkw.demo.syn;

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 {
        //根据构造方法中传入的flag参数，确定线程执行读操作还是写操作
        private boolean flag;
        public ReadWriteThread(boolean flag){
            this.flag = flag;
        }
        @Override                                                                    
        public void run() {
            if(flag){
                //构造方法中传入true，执行写操作
                write();
            }else{
                //构造方法中传入false，执行读操作
                read();
            }
        }
    }

    public static void main(String[] args)  {
        SynchronizedDemo synDemo = new SynchronizedDemo();
        //启动线程执行写操作
        synDemo .new ReadWriteThread(true).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //启动线程执行读操作
        synDemo.new ReadWriteThread(false).start();
    }
}

package mkw.demo.vol;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class VolatileDemo {

    private Lock lock = new ReentrantLock();
    private int number = 0;
    
    public int getNumber(){
        return this.number;
    }
    
    public void increase(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        lock.lock();
        try {
            this.number++;
        } finally {
            lock.unlock();
        }
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        final VolatileDemo volDemo = new VolatileDemo();
        for(int i = 0 ; i < 500 ; i++){
            new Thread(new Runnable() {
                
                @Override
                public void run() {
                    volDemo.increase();
                }
            }).start();
        }
        
        //如果还有子线程在运行，主线程就让出CPU资源，
        //直到所有的子线程都运行完了，主线程再继续往下执行
        while(Thread.activeCount() > 1){
            Thread.yield();
        }
        
        System.out.println("number : " + volDemo.getNumber());
    }
}