volatile关键字
1、可见性
前提:变量保存在主存,如果线程修改变量要先将主存拷贝到线程缓存修改,之后再同步到主存。
可见性:是指只能满足多线程写,读的时候,值正确。
原理:
1、volatile 声明的变量
假设B线程缓存了主存的变量并修改(原子修改不是++这种非原子操作),线程A来读取主存的变量,jvm会强制将线程B的修改后变量同步到主存以后,再给A来用。多个线程写也是先等一个写完,同步到主存另一个开始写。
2、不加volatile,
假设B线程缓存了主存的变量并修改(原子修改不是++这种非原子操作),线程A来读取主存的变量,或得的是之前的值,并非是B修改后的值,这是不正确的。
使用场景线程中状态的改变等。例如如下代码
private volatile boolean isStop;
private void testVisible(){
//工作线程
new Thread(new Runnable() {
@Override
public void run() {
while (!isStop){
Log.i("qinxue","running");
}
}
}).start();
//控制线程
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
isStop = true;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
3、非原子操作写例如++,看下面代码
private volatile int count = 0;
private Object object = new Object();
private void testVolatile() {
for (int i = 0; i < 2000; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
long sleepTime = (long) (Math.random() *60); //为了更容易出现竞争
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 添加synchronized互斥之后可以保证正确
// synchronized (object){
// count++;
// }
count++;
Log.i("qinxue", "count: " + count);
}
}).start();
}
}
前提:i++,包含3个步骤
1,从内存读取i当前的值
2,加1
3,把修改后的值刷新到内存
结果count<=2000 即使添加了 volatile 关键字声明,由于++不是原子性的,1和3是原子性,在1和3之前还有操作,可能有线程一起做了。这样就少加了,所以是count<=2000.
控制线程修改 isStop,while判断是等修改完成后获取的。
2、防止指令重排
jvm会优化一些指令,例如new 一个对象
1.分配对象的内存空间。
2.初始化对象。
3.设置instance指向刚分配的内存地址。
其中2和3可能被优化成3,2。
原理:
1、未使用 volatile 声明 A线程 getInstance 在new Singleton()指令重排了,虽未初始化对象,但是instance!=null了, B线程获取到instance,这是肯定是用不了的。出现错误。
2、使用 volatile 声明 A线程 getInstance 在new Singleton() 不会指令重排,B线程获取到instance时肯定是初始化完成的了,对B线程来说是可用的。
最常见的是单例模式的一种写法
public class Singleton {
private volatile static Singleton instance = null;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}