关键字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);
}
}
程序运行后根本停止不下来，因为这个例子是单线程的，线程从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);
}
}
程序运行如图所示，死循环在线程开启不久就被主线程给关闭了开关。
但据说上述代码在-server服务器模式中64bit的JVM上时，会出现死循环，解决办法是使用volatile关键字。
关键字volatile的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值。
使用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();
}
}
}
从结果上来看线程明显不是同步的，明明我们使用了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阶段：用工作内存数据刷新主内存对应变量的值。
在多线程环境中，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();
}
}
}
嗯嗯嗯嗯？？？书上说的都是骗人的？？？
mmp，继续分析下原因。。。毕竟我是小白，写书的是大佬，相比于大佬还是我错误的几率更高。
作者外出查询与思考ing
作者外出查询与思考ed
作者回归。。。
mmp，作者果然是小白，明明原因十分的简单，就是addCount()没有同步造成的，AtomicInteger 虽然具有原子性，但是方法与方法间的调用却不是原子的，没招了，加锁吧。
加锁完后ok了。
