您现在的位置:首页 > >

Java并发 volatile可见性的验证

发布时间:



文章目录
普通读 无法及时获得 主内存变量volatile读 及时获得 主内存变量普通读+sleep普通读+同步块同步块 遭遇 锁消除
普通读+System.out.println总结


普通读 无法及时获得 主内存变量

public class volatileTest {
static boolean flag = false;//非volatile变量

public static void main(String[] args) throws Exception {
new Thread(new Runnable() {
@Override
public void run() {
while(!flag){
};
}
}).start();
Thread.sleep(100);
flag = true;
System.out.println("主线程运行完毕");
}
}

主线程已经修改了flag为true,但子线程一直不会退出循环,因为子线程一直没有同步到 主内存中的变量的值。
截图可见程序一直没有退出,使用dump threads后:

"Thread-0" #12 prio=5 os_prio=0 tid=0x0000000022d89800 nid=0x168 runnable [0x00000000248df000]
java.lang.Thread.State: RUNNABLE
at volatileTest$1.run(volatileTest.java:10)
at java.lang.Thread.run(Thread.java:745)

volatile读 及时获得 主内存变量

public class volatileTest {
static volatile boolean flag = false;//volatile变量

public static void main(String[] args) throws Exception {
new Thread(new Runnable() {
@Override
public void run() {
while(!flag){
};
}
}).start();
Thread.sleep(100);
flag = true;
System.out.println("主线程运行完毕");
}
}

加了一个volatile关键字,子线程就能检测到flag的变化了。子线程会退出
普通读+sleep

public class volatileTest {
static boolean flag = false;//非volatile变量

public static void main(String[] args) throws Exception {
new Thread(new Runnable() {
@Override
public void run() {
while(!flag){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}
}).start();
Thread.sleep(100);
flag = true;
System.out.println("主线程运行完毕");
}
}

加了sleep,子线程会退出


其实就算变量不是volatile的,JVM也会尽量去保证可见性。最开始的例子,由于CPU一直执行循环,没有其他时间来获取 主内存中的变量的最新值,但加了sleep后,CPU就有时间去获取 主内存中的东西了。


普通读+同步块

public class volatileTest {
static boolean flag = false;//非volatile变量
static Object sync = new Object();

public static void main(String[] args) throws Exception {
new Thread(new Runnable() {
@Override
public void run() {
while(!flag){
synchronized (sync) {}//随便synchronized一个对象
//synchronized (this)也可以
};
}
}).start();
Thread.sleep(100);
flag = true;
System.out.println("主线程运行完毕");
}
}

加了同步块,子线程会退出


这是因为synchronized具体过程是:


    获得同步锁;清空工作内存;从主内存拷贝对象副本到工作内存;执行代码(计算或者输出等);刷新主内存数据;释放同步锁。

简单的说,synchronized进入时,会将 主内存中最新的变量,拷贝进 自己线程 的工作内存。synchronized退出时,会把 自己线程的工作内存的变量 弄进 主内存中。


同步块 遭遇 锁消除

public class volatileTest {
static boolean flag = false;//非volatile变量

public static void main(String[] args) throws Exception {
new Thread(new Runnable() {
@Override
public void run() {
while(!flag){
synchronized (new Object()){}
};
}
}).start();
Thread.sleep(100);
flag = true;
System.out.println("主线程运行完毕");
}
}

子线程不会退出


原因是:synchronized (new Object()){}中这个Object永远不可能逃逸到同步块以外去,所以同步操作其实根本不需要执行了,既然没有执行同步,那么相当于这里是啥也没有。


普通读+System.out.println

public class volatileTest {
static boolean flag = false;

public static void main(String[] args) throws Exception {
new Thread(new Runnable() {
@Override
public void run() {
while(!flag){
System.out.println("子线程running");
};
}
}).start();
Thread.sleep(100);
flag = true;
System.out.println("主线程运行完毕");
}
}

加了System.out.println子线程会退出


因为out这个PrintStream实例的println实现是:


public void println(String x) {
synchronized (this) {
print(x);
newLine();
}
}

因为它也有同步块。


总结
volatile读写,保证可见性。普通读写,不保证可见性(可能会保持,也可能不保持)。


友情链接: 医学资料大全 农林牧渔 幼儿教育心得 小学教育 中学 高中 职业教育 成人教育 大学资料 求职职场 职场文档 总结汇报