volatile关键字

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

volatile关键字与死循环

如果不是在多继承的情况下，使用继承Thread类和实现Runnable接口在取得程序运行的结果上并没有什么太大的区别。如果一旦出现“多继承”的情况，则用实现Runnable接口的方式来处理多线程的问题就是很有必要的。

代码清单1 死循环

public class PrintString {
	private boolean isContinuePrint = true;
	public boolean isContinuePrint() {
		return isContinuePrint;
	}
	public void setContinuePrint(boolean isContinuePrint) {
		this.isContinuePrint = isContinuePrint;
	}
	public void printStringMethod() {
		try {
			while (isContinuePrint == true)
				System.out.println("run printStringMethod threadName=" + Thread.currentThread().getName());
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
public class Run {
	public static void main(String[] args) {
		PrintString printStringService=new PrintString();
		printStringService.printStringMethod();
		System.out.println("我要停止它！ stopThread="+Thread.currentThread().getName());
	  printStringService.setContinuePrint(false);
	}
}

程序开始运行后，根本停不下来，结果如图1所示。
停不下来的原因主要就是main线程一直在处理while()循环，导致程序不能运行后面的代码。

图1 停不下来的程序

解决同步死循环

采用多线程，解决死循环。
代码清单2 解决死循环

public class PrintString implements Runnable{
	private boolean isContinuePrint = true;
	public boolean isContinuePrint() {
		return isContinuePrint;
	}
	public void setContinuePrint(boolean isContinuePrint) {
		this.isContinuePrint = isContinuePrint;
	}
	public void printStringMethod() {
		try {
			while (isContinuePrint == true)
				System.out.println("run printStringMethod threadName=" + Thread.currentThread().getName());
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public void run() {
	printStringMethod();
	}
}
public class Run {
	public static void main(String[] args) {
		PrintString printStringService=new PrintString();
		new Thread(printStringService).start();
		System.out.println("我要停止它！ stopThread="+Thread.currentThread().getName());
	  printStringService.setContinuePrint(false);
	}
}
`

运行结果如图2，但当上面的代码运行在-server服务器模式中64bit的JVM时，会出现死循环。解决的办法是使用volatile关键字。
关键字volatile的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值。

图2 程序被停止了

解决异步死循环

在探讨volatile之前先做一个测试。
代码清单3 JVM设置为 -Server

public class RunThread extends Thread{
    //volatile private boolean isRunning = true;
	private boolean isRunning = true;
	public boolean isRunning() {
		return isRunning;
	}
	public void setRunning(boolean isRunning) {
		this.isRunning = isRunning;
	}
	@Override
	public void run() {
   System.out.println("进入run了");
		while (isRunning==true){
	   
   }
   System.out.println("线程被停止了！");
	}
}
public class Run {
	public static void main(String[] args) {
		try {
			RunThread thread = new RunThread();
			thread.start();
			Thread.sleep(1000);
			thread.setRunning(false);
			System.out.println("已经赋值为false");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

在win10结合JDK64bit的环境中，使用Eclipse开发环境运行后的结果如图3所示。

图3 打印结果

但是如果使用同样的代码，让他们运行在JVM设置为Server服务器的环境中，设置如图4所示。

图4 配置JVM为-server模式

运行结果如图5所示，代码System.out.println("线程被停止了！"); 从未被执行。

图5 出现了死循环

是什么样的原因造成将JVM设置为-server使出现死循环呢？在启动RunThread.java线程时，变量private boolean isRunning = true;存在于公共堆栈及线程的私有堆栈中。在JVM被设置为-server模式时为了线程运行的效率，线程一直在私有堆栈中取得isRunning的值为true。而代码thread.setRunning(false);虽然被执行，更新的却是公共堆栈中的isRunning变量值false，所以一直就是死循环的状态。内存结果如图6所示。

图6 线程的私有堆栈

这个问题其实就是私有堆栈中的值和公共堆栈中的值不同步造成的。解决这样的问题就要使用volatile关键字，它主要的作用就是当线程访问isRunning这个变量时，强制性从公共堆栈中进行取值。
在代码清单3中，定义变量isRunning前加上volatile，运行结果如图7.

图7 在-server服务器模式不再出现死循环

通过使用volatile关键字，强制的从公共内存中读取变量的值，内存结构如图8所示。

图8 读取公共内存

使用volatile关键字增加了实例变量在多个线程之间的可见性。但volatile关键字最致命的缺点是不支持原子性。
下面将关键字synchronized和volatile进行一下比较：

关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且volatile只能修饰变量，而synchronized可以修饰方法，以及代码块。随着JDK新版本的发布，synchronized关键字在执行效率上得到了很大提升，在开发中使用synchronized关键字的比率还是比较大。
多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。
volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步。
再次重申一下，关键字volatile解决的是变量在多个线程之间的可见性；而synchronized关键字解决的是多个线程之间访问资源的同步性。

线程安全包含原子性和可见性两个方面，Java的同步机制都是围绕这两个方向来确保线程安全的。