Java多线程-----volatile关键字详解

   volatile原理

    Java语言提供了一种稍弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后，

编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄

存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值

     当对非 volatile 变量进行读写的时候，每个线程先从内存拷贝变量到CPU缓存中。如果计算机有多个CPU，每个线程可能在不同的CPU

上被处理，这意味着每个线程可以拷贝到不同的 CPU cache 中。而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读。

    当一个变量定义为 volatile 之后，将具备两种特性：

　　1.保证此变量对所有的线程的可见性，这里的“可见性”，指当一个线程修改了这个变量的值，volatile 保证了新值能立即同步到主内存，

以及每次使用前立即从主内存刷新。但普通变量做不到这点，普通变量的值在线程间传递均需要通过主内存来完成，即复制变量值到当前线

程缓存中修改，然后再返回给主内存。

　　2.禁止指令重排序优化。什么是指令重排序：是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理。

   并发编程的三个特性

1.原子性

原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行

2.可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值

//线程1执行的代码
int i = 0;
i = 10;

//线程2执行的代码
j = i;

当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。

此时线程2执行 j = i，它会先去主存读取i的值并加载到CPU2的缓存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.

这就是可见性问题，线程1对变量i修改了之后，线程2没有立即看到线程1修改的值。

3.有序性

有序性：即程序执行的顺序按照代码的先后顺序执行

int i = 0;
int j = 0;
i = 10;   //语句1
j = 1;    //语句2

语句可能的执行顺序如下：

• 1）语句1 语句2
• 2）语句2 语句1

语句1一定在语句2前面执行吗？答案是否定的，这里可能会发生执行重排（Instruction Reorder）。一般来说，处理器为了提高程序运行效率，

可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序在单线程环境下最终执行结果和

代码顺序执行的结果是一致的。

   volatile实例

1.变量没有使用volatile关键字

package com.thread.volatileintroduce;

/**
 * 没有使用Volatile关键字
 *
 * @author yyx 2019年1月12日
 */
public class NoVolatile {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        new Thread(td).start();

        while (true) {
            if (td.isFlag()) {
                System.out.println("------------------");
                break;
            }
        }
    }
}

class ThreadDemo implements Runnable {
    private boolean flag = false;

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        flag = true;
        System.out.println("flag=" + isFlag());
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}
运行结果：flag=true

主线程不会打印出“--------------”

2.使用volatile关键字

package com.thread.volatileintroduce;

/**
 * 使用Volatile关键字
 * volatile 关键字：当多个线程进行操作共享数据时，可以保证内存中的数据可见。 相较于 synchronized
 * 是一种较为轻量级的同步策略。
 *
 * 注意： 1. volatile 不具备“互斥性” 2. volatile 不能保证变量的“原子性”
 *
 * @author yyx 2019年1月12日
 */
public class HaveVolatile {
    public static void main(String[] args) {
        SubThread subThread = new SubThread();
        new Thread(subThread).start();

        while (true) {
            if (subThread.isFlag()) {
                System.out.println("------------------");
                break;
            }
        }
    }
}

class SubThread implements Runnable {
    private volatile boolean flag = false;

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        flag = true;
        System.out.println("flag=" + isFlag());
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}
运行结果：

flag=true
------------------

注意：volatile不能保证线程的安全

• volatile不具备“互斥性”
• volatile不能保证变量的“原子性”