JUC多线程及高并发-Volatile

• • • JUC
    • Volatile 是什么？
    • JMM 内存模型可见性
    • Volatile可见性
    • Volatile不保证原子性
    • Volatile指令重排
    • 单例模式多线程下不安全现象（有序性）

java.util.concurrent

Java 虚拟机提供的轻量级同步机制

保证可见性、 不保证原子性、禁止指令重排

JMM是一个抽象的概念，并不真实存在，是一种规范。

概念：
JVM 运行程序靠的是线程，每条线程都会有一个工作内存（有的称为栈空间），工作线程是每个线程的私有数据区域，Java 内存模型中规定所有变量存储在主内存（主内存是共享区域），所有线程都可以访问，线程对变量的值操作，必须在工作内存中进行。具体操作是，每个线程对共享内存中进行拷贝，然后进行变量操作，操作完成将变量返回到主内存中。

每个线程中工作内存不可以互相访问，线程间的通讯通过主内存完成

JVM (虚拟机)

JMM (内存模型) 可见性

public class VolatileDemo
{

    public static void main(String[] args) {
        MyData myData = new MyData();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "：come in");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.setAge();
            System.out.println(Thread.currentThread().getName() + myData.age);
        },"VolatileDemo").start();

        while(myData.age == 25){
        }
        System.out.println(Thread.currentThread().getName() + "：over" + myData.age);
    }


}

class MyData{

	// 没有添加volatile,没有可见性
    int age = 25;
    // 添加volatile,验证变量可见性
    // volatile int age = 25;

    public void setAge() {
        this.age = 35;
    }
}

使用 int age = 25;

使用 volatile int age = 25; 当进行while-true时，将改变的值可以读取，所以age具有可见性，执行结束

多线程情况下，值最后没有达到想要的值
使用Syslize能解决，但是太重量级了，使用Volatile + AtomicInteger 实现

package com.xin;

import java.io.Serializable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;



public class VolatileAtomicDemo {

    public static void main(String[] args) {

        MyNumber myNumber = new MyNumber();

        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    myNumber.numberAdd();
                    myNumber.numberAddSynchronized();
                    myNumber.numberAddAtomic();
                }
            },String.valueOf(i)).start();
        }

        while (Thread.activeCount() >2){
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName() + "-- number：" + myNumber.number);
        System.out.println(Thread.currentThread().getName() + "-- synchronizedNumber：" + myNumber.synchronizedNumber);
        System.out.println(Thread.currentThread().getName() + "-- atomicNumber：" + myNumber.atomicNumber);

    }


}


class MyNumber {

    volatile int number = 0;
    volatile int synchronizedNumber = 0;
    AtomicInteger atomicNumber = new AtomicInteger(0);

    public void numberAdd() {
        number++;
    }

    public synchronized void numberAddSynchronized() {
        synchronizedNumber++;
    }

    public void numberAddAtomic() {
        atomicNumber.getAndIncrement();
    }

}

指令存在数据依赖性

多线程下，线程交替执行，编译器指令重排存在
多个线程的变量不可以保证一致性，结果无法判断

Memory Barrier (内存屏障) ，是一个CPU指令

插入内存屏障，在内存屏障前后禁止指令执行重排排序优化，作用是强制刷新CPU缓存数据，因此CPU读出数据最新版本

工作内存和主内存同步延迟导致现象
使用 Synchronized 和 Volatile都可以解决，使修改的变量立刻对其他线程可见

对于指令重排导致的可见性和有序性，可以使用Volatile关键字解决，Volatile 另一个作用禁止重排序优化

package com.xin;


public class VolatileMemoryDemo {

    private static volatile VolatileMemoryDemo instance = null;

    private VolatileMemoryDemo() {
        System.out.println(Thread.currentThread().getName() + "t :构造方法VolatileMemoryDemo");
    }

    // DCL(双端检索机制)
    public static VolatileMemoryDemo getInstance() {
        if (instance == null) {
            synchronized (VolatileMemoryDemo.class) {
                if (instance == null) {
                    instance = new VolatileMemoryDemo();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {

        for (int i = 1; i < 10; i++) {
            new Thread(() -> {
                VolatileMemoryDemo.getInstance();
            },String.valueOf(i)).start();
        }

    }

}

DCL (双端检锁)机制不一定线程安全，原因是有指令重排序的存在，加入volatile可以禁止指令重排

原因在于某一个线程执行到第一 次检测， 读取到的instance 不为nulll时，instance的引用对象可能没有完成初始化。

instance = new SingletonDemo0)可以分为以下3步完成(伪代码)

memory= allocate(; //1.分配对象内存空间
instance(memory); //2. 初始化对象
instance = memory; //3.设置 instance指向刚分配的内存地址，此时instance! =null

步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，

因此这种重排优化是允许的。

memory= allocate(; //1分配对象内存空间
instance = memory; //3 设置instance指向刚分配的内存地址，此时instance!= null, 但是对象还没初始化完成
instance(memory); //2. 初始化对象