二、volatile关键字 - 内存可见性

标签：start   任务   调用   stat   轻量   ack   一个   []   加锁   

1、内存可见性

? (程序在运行时，jvm会为每一个执行任务的线程都分配一个独立的缓存，用于提高效率)

? 我觉得可以这样来理解：

? 内存：啥是内存？就是可以理解成电脑当中的内存条，程序创建个变量，都放在内存当中(浅显理解)

? 可见性：就是多个线程在运行过程中，当某一个线程对共享的变量作出修改后，其他线程能不能看到该变量是否已经被改变的现象。

? 共享变量：线程在对该变量执行操作的时候，会从主内存中将该变量读到自己线程的缓存中去执行具体操作，执行完后再归还主内存，大家一起共享。

? 理解了上面的三个概念后：

? 内存可见性：是指多个线程共享同一变量，如果某一线程对共享变量作出修改，可以被其他线程看到，那就说明该共享变量在各线程之间是可见的。

? 因此，内存可见性问题，就是多个线程同时操作共享数据是，彼此产生了不可见的现象。

? 解决这一问题，我们一般的思路就是使用同步锁(synchronized)来解决，因为同步锁能够保证内存的刷新，去主内存中读取数据，保证每次执行的都是最新的变量。但是，加锁这种情况会使程序的效率极低，因此，在解决内存可见性这一问题上，就出现了volatile关键字……..

2、volatile 关键字

? Java 提供了一种稍弱的同步机制，即 volatile 变量，用来确保将变量的更新操作通知到其他线程，可以保证内存中的数据可见（原理：其调用了计算机底层的代码叫内存栅栏，时刻的将线程缓存中的数据刷新到主内存当中去，因此也就可以将volatile的操作理解为就是在主存中完成的）。

相较于synchronized关键字，可以将 volatile 看做一个轻量级的同步策略，但是又与锁有些不同：

1?? volatile不具备"互斥性"，就是说多线程情况下，一个线程访问共享数据，其他多个线程也可以访问该数据，只不过是内存中完成而已

2?? volatile不能保证变量状态的“原子性操作”

效率：在解决内存可见性的问题上，volatile的效率要高于synchronized的效率，但是volatile的效率主要是浪费在指令重排序上。

代码示例：

public class TestVolatile {
    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 volatile boolean flag=false;
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag=true;
        System.out.println("flag="+isFlag());
    }
    public boolean isFlag(){
        return flag;
    }
    public void setFlag(boolean flag){
        this.flag=flag;
    }
}

结果：

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

如果不使用volatile关键字

flag=true

二、volatile关键字 - 内存可见性

标签：start   任务   调用   stat   轻量   ack   一个   []   加锁   

原文地址：https://www.cnblogs.com/zongheng14/p/10703820.html