案例
一、volatile修饰的变量的可见性
变量isRunning 不用volatile修饰的情况
public class VolatileTest extends Thread{
private boolean isRunning = true;
private void setRunning(boolean isRunning){
this.isRunning = isRunning;
}
@Override
public void run(){
System.out.println("子线程进入run方法");
System.out.println("子线程执行中。。。isRunning=" + this.isRunning);
while (isRunning == true){
//
}
System.out.println("子线程停止");
}
/**
* 当isRunning不用volatile修饰的时候,主线程修改了isRunning的值,volatileTest.start()开启的线程并不知道,该线程不会停止
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
VolatileTest volatileTest = new VolatileTest();
volatileTest.start();
Thread.sleep(3000);
volatileTest.setRunning(false);
System.out.println("主线程将isRunning的值设置为false");
Thread.sleep(1000);
System.out.println("isRunning=" + volatileTest.isRunning);
}
}
根据java的内存模型,两个线程中使用到的变量都从主内存中获取,拷贝一份放到各自的线程的工作内存中,对于普通的变量,在两个线程之间是互不可见的,所以在主线程将isRunning的值设置为false之后,子线程并不知道,子线程并不会停止。
变量isRunning 用volatile修饰的情况
public class VolatileTest extends Thread{
private volatile boolean isRunning = true;
private void setRunning(boolean isRunning){
this.isRunning = isRunning;
}
@Override
public void run(){
System.out.println("子线程进入run方法");
System.out.println("子线程执行中。。。isRunning=" + this.isRunning);
while (isRunning == true){
//
}
System.out.println("子线程停止");
}
/**
* 当isRunning不用volatile修饰的时候,主线程修改了isRunning的值,volatileTest.start()开启的线程并不知道,该线程不会停止
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
VolatileTest volatileTest = new VolatileTest();
volatileTest.start();
Thread.sleep(3000);
volatileTest.setRunning(false);
System.out.println("主线程将isRunning的值设置为false");
Thread.sleep(1000);
System.out.println("isRunning=" + volatileTest.isRunning);
}
}
当A线程在自己的工作内存中修改了volatile修饰的变量,会将修改后的新值刷新到主内存中,并通知其他线程从新从主内存中获取该值,保证了变量在不同线程中的可见性
二、volatile修饰的变量的原子性
普通变量
public class VolatileNoAtomic extends Thread{
private static volatile int count;
private static void addCount(){
for (int i = 0; i < 1000; i++) {
count++;
}
System.out.println(count);
}
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
addCount();
}
public static void main(String[] args) {
VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
//创建十个线程对象
for (int i = 0; i < 10; i++) {
arr[i] = new VolatileNoAtomic();
}
//启动十个线程,每个线程对执行count++ 1000次
for (int i = 0; i < 10; i++) {
arr[i].start();
}
}
}
上面的代码,创建了10个线程,每个线程调用实例对象执行1000次count++操作,每次线程阻塞100ms,正常情况下,由于count具有可见性,在每个线程中执行1000次count++,共10个线程执行,最后count的结果应该是10000。而实际情况却是这样的:
从上面输出结果可以看出count结果不为10000,这是因为当一个线程在从住内存中获取count最新值进行count++的时候,过程为三步:
- 首先从住内存取值赋值给工作内存count
- 执行count++
- 将count新值刷新到主内存
线程1对变量进行自增操作,假如线程1先读取了变量count的原始值10,然后线程1被阻塞了,然后线程2对变量进行自增操作,线程2也去读取变量count的原始值,由于线程1只是对变量count进行读取操作,而没有对变量进行修改操作(写入主内存),所以不会导致线程2的工作内存中缓存变量count无效,所以线程2会直接去主存读取count的值,发现count的值是10,然后进行加1操作,并把11写入工作内存,最后写入主存,此时线程1再对count进行自加操作,count的值已经不是最新的值,所以这就导致了最后的结果不是10000
原子类变量
使用原子类保证原子性
public class VolatileNoAtomic extends Thread{
private static AtomicInteger count = new AtomicInteger(0);
private static void addCount(){
for (int i = 0; i < 1000; i++) {
count.incrementAndGet();
}
System.out.println(count);
}
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
addCount();
}
public static void main(String[] args) {
VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
for (int i = 0; i < 10; i++) {
arr[i] = new VolatileNoAtomic();
}
for (int i = 0; i < 10; i++) {
arr[i].start();
}
}
}
单例模式中volatile的作用
public class Singleton {
private static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
public static void main(String[] args) {
Singleton.getInstance();
}
}
这段代码看起来很完美,很可惜,它是有问题。主要在于instance = new Singleton()
这句,这并非是一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情。
- 给 instance 分配内存
- 调用 Singleton 的构造函数来初始化成员变量
- 将instance对象指向分配的内存空间(执行完这步instance 就为非 null 了)
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者,则在 3 执行完毕、2 未执行之前,另一个线程执行了getInstance()方法,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,然后顺理成章地报错,解决方法就是将 instance 变量声明成 volatile 就可以了。
给instance变量赋值部分代码如下: