volatile关键字

关键字volatile的作用是使变量在多个线程间可见。

在讲解volatile关键字之前我们先来看下下面这个例子：

public class DemoPrint {

    //开关
    private Boolean flag = true;
    
    public Boolean getFlag() {
        return flag;
    }
    //设置开关
    public void setFlag(Boolean flag) {
        this.flag = flag;
    }
    
    public void println() {
        try {
            while (flag) {
                System.out.println("running..........threadName:" 
                        + Thread.currentThread().getName());
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        DemoPrint print = new DemoPrint();
        print.println();
        System.out.println("stop..........." + Thread.currentThread().getName());
        print.setFlag(false);
    }
}

image.png

程序运行后根本停止不下来，因为这个例子是单线程的，线程从while循环里根本出不来，更别提在后面将开关给关上了。

我们思考一下，能不能利用多线程来将这个死循环的开关给彻底的关上呢？

public class DemoPrint implements Runnable{

    //开关
    private Boolean flag = true;
    
    public Boolean getFlag() {
        return flag;
    }
    //设置开关
    public void setFlag(Boolean flag) {
        this.flag = flag;
    }
    
    public void println() {
        try {
            while (flag) {
                System.out.println("running..........threadName:" 
                        + Thread.currentThread().getName());
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    @Override
    public void run() {
        println();
    }
}

首先我们创建DemoPrint如上所示，

public class Test {
    public static void main(String[] args) {
        DemoPrint print = new DemoPrint();
        Thread thread = new Thread(print);
        thread.start();
        System.out.println("stop..........." + Thread.currentThread().getName());
        print.setFlag(false);
    }
}

image.png

程序运行如图所示，死循环在线程开启不久就被主线程给关闭了开关。

但据说上述代码在-server服务器模式中64bit的JVM上时，会出现死循环，解决办法是使用volatile关键字。

关键字volatile的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值。

image.png

使用volatile关键字增加了实例变量在多个线程之间的可见性。但是volatile关键字最致命的缺点是不支持原子性。

下面将关键字synchronized和volatile进行比较：
1）关键字volatile是线程同步的轻量级视线，所以volatile性能肯定比synchronized要好，并且volatile只能修饰变量，而synchronized可以修饰方法，以及代码块。

2）多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。

3）volatile能保证数据的可见性，但是不能保证原子性；而synchronized可以保证原子性，也可以简介保证可见性，因为他会将私有内存和公共内存中的数据做同步。

4）关键字vloatile解决的是变量在多个线程之间的可见性；而synchronized关键字解决的是多个线程之间访问资源的同步性。

vloatile非原子性

关键字volatile虽然增加了实例变量在多个线程之间的可见性，但它却不具备同步性，那么也就不具备原子性。

下面我们来看一个例子：

package other.thread7;

public class VolatileThread extends Thread{

    public volatile static int count;
    
    private static void addCount() {
        for (int i = 0; i < 100; i++) {
            count++;
        }
        System.out.println(count);
    }
    
    @Override
    public void run() {
        addCount();
    }
}

public class Test {
    public static void main(String[] args) {
        
        VolatileThread[] arr = new VolatileThread[100];
        for (int i = 0; i < 100; i++) {
            arr[i] = new VolatileThread();
        }
        for (int i = 0; i < 100; i++) {
            arr[i].start();
        }
    }
}

image.png

从结果上来看线程明显不是同步的，明明我们使用了volatile将变量从公共内存中取值，按理来说数据应该是0,100.200...这样同步的才对啊。

关键字volatile主要使用的场合是在多个线程中可以感知实例变量被更改了，并且可以获得最新的值使用，也就是用多线程读取共享变量时可以获得最新值使用。

但是在这里需要注意的是：如果修改了实例变量中的数据，比如说count++，也就是count=count + 1，则这样的操作其实并不是一个原子操作也就是非线程安全的，它包含三步
1）从内存中取出count的值；
2）计算count的值；
3）将count的值写入内存
如果在第二步时，另外一个线程也修改了count的值，那么这个时候就会出现脏读数据。解决的办法就是使用synchronized关键字，所以说volatile本身并不处理数据的原子性，而是强制对数据的读写及时影响到主内存的。

用图来演示一下用关键字volatile时出现非线程安全的原因：
1）read和load阶段：从主内存赋值变量到当前线程的工作内存；
2）use和assign阶段：执行代码，改变共享变量值；
3）store和write阶段：用工作内存数据刷新主内存对应变量的值。

image.png

在多线程环境中，use和assign是多次出现的，但这一操作并不是原子性，也就是在read和load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，也就是私有内存和公共内存中的变量不同步，所以计算出来的结果和预期不一样，也就出现了非线程安全问题。

对于用volatile修饰的变量，JVM虚拟机只是保证从主内存加载到线程工作内存的值是最新的，例如线程1和线程2在进行read和load的操作用，发现主内存中的count的值都是5，那么都会加载这个最新的值。也就是说volatile关键字解决的是变量读时的可见性问题，但无法保证原子性，对于多个线程访问同一个实力变量还是需要加锁同步。

除了在count++操作时使用synchronized关键字实现同步外，还可以使用AtomicInteger原子类进行实现。

原子操作时不能分割的整体，没有其他线程能够中断或检查正在原子操作中的变量。一个原子（atomic）类型就是一个原子操作可用的类型，它可以在没有锁的情况下做到线程安全。

嗯！书上是这么写的，那么让我们来验证一下。

package other.thread7;

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileThread extends Thread{

    public volatile static  AtomicInteger count = new AtomicInteger(0);
    
    private static void addCount() {
        for (int i = 0; i < 100; i++) {
            count.incrementAndGet();
        }
        System.out.println(count);
    }
    
    @Override
    public void run() {
        addCount();
    }
}

public class Test {
    public static void main(String[] args) {
        
        VolatileThread[] arr = new VolatileThread[100];
        for (int i = 0; i < 100; i++) {
            arr[i] = new VolatileThread();
        }
        for (int i = 0; i < 100; i++) {
            arr[i].start();
        }
    }
}

image.png

嗯嗯嗯嗯？？？书上说的都是骗人的？？？

mmp，继续分析下原因。。。毕竟我是小白，写书的是大佬，相比于大佬还是我错误的几率更高。

作者外出查询与思考ing

作者外出查询与思考ed

作者回归。。。

mmp，作者果然是小白，明明原因十分的简单，就是addCount()没有同步造成的，AtomicInteger 虽然具有原子性，但是方法与方法间的调用却不是原子的，没招了，加锁吧。

image.png

加锁完后ok了。