JUC（java.unit.concurrent）之 “volatile” 关键字

volatile关键字的作用

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 {
    //给变量添加volatile关键字修饰，以确保flag的数据可见性
    private volatile boolean flag = false;
    //get方法
    public boolean isFlag() {
        return flag;
    }
    //set方法
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
        System.out.println("flag=" + isFlag());
    }

}

勤快的小伙伴可以动手尝试一下，起初flag变量在没有添加volatile关键字修饰之前，执行main方法

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

这一段代码中的打印输出是不执行的，但是

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

这里的输出打印flag的值已经是true了。为什么会不执行if判断里边的输出打印呢？？
这里的原因是因为Java内存模型规定所有的变量都是存在主存当中，每个线程都有自己的工作内存。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。并且每个线程不能访问其他线程的工作内存。变量的值何时从线程的工作内存写回主存，无法确定。
这样一说的话，为什么会出现if判断不执行的情况就很好理解了。main（）方法去主存中读取flag时run()方法还没有来得及把对flag赋值后的新flag值写回到主存中。也就是说main（）方法从主存中读进自身所在线程工作内存中的flag值还是false，所以说if判断里的输出打印并不会执行。
然而我们想要达到的效果是当flag的值改变之后，while循环可以读取到并判断然后执行输出打印
当我们flag添加volatile修饰以后

//给变量添加volatile关键字修饰，以确保flag的数据可见性
    private volatile boolean flag = false;

如果flag的值发生了改变，其他线程的代码立马可见，这样就保证了我们的if判断可以顺利执行

synchronnized和volatile的区别

简单来说，有如下两个区别：
1.volatile只能保证可见性,不能保证原子性
2.synchronized既保证可见性也能保证原子性,但是效率相对要比volatile低得多
以上纯属个人见解

volatile关键字存在的问题

volatile关键字修饰后，可以保证数据可见性但不能保证原子性。什么是原子性呢？举个简单的例子

public class TestAtomicDemo {
    public static void main(String[] args) {
        AtomicDemo ad = new AtomicDemo();
        for (int i = 0; i <10 ; i++) {
            new Thread(ad).start();
        }
    }

}

class AtomicDemo implements Runnable {
    private int serialNumber = 0;
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(getSerialNumber());
    }
    //get方法
    public int getSerialNumber() {
        return serialNumber++;
    }
}

当我们执行main（）方法去创建多个线程并发访问run方法的时候，存在两个线程读到的serialNumber的值是相同的，又同时对serialNumber做了++操作，就导致两个甚至多个线程执行完打印出的serialNumber是相同的值。
怎么解决这个问题呢？这就引申出了一个新的概念：原子变量

下一篇：JUC（java.unit.concurrent）之 “原子变量
”