volatile的理解
首先上代码
public class VolatileTest implements Runnable{
private boolean isStop;
public static void main(String[] args) {
// TODO Auto-generated method stub
VolatileTest v = new VolatileTest();
Thread t = new Thread(v);
t.start();
try{
Thread.sleep(1000);
}catch(Exception e){
}
v.isStop = true;
}
public void run() {
while(!isStop){
}
System.out.println("停止");
}
}
运行这段代码,把jvm设置为server模式,主线程在启动子线程后,休眠1s,子线程在这个时候进入一个条件循环,1s后主线程把循环条件置为true,但是这个时候会发现子线程进入了死循环,这是因为无法看到主线程对isStop变量的修改.
普遍的解释说法是线程内部维护了一个isStop的变量副本,子线程为了提高运行效率,从变量副本里取isStop,所以主线程对isStop的修改对于子线程不可见.
那么问题来了,这个变量副本是存在哪里的呢?
从rocomp博客中看到
线程对共享变量的所有操作都必须在自己的工作内存（working memory,是cache和寄存器的一个抽象，而并不是内存中的某个部分，这个解释源于《Concurrent Programming in Java: Design Principles and Patterns, Second Edition》§2.2.7，原文：Every thread is defined to have a working memory (an abstraction of caches and registers) in which to store values. 有不少人觉得working memory是内存的某个部分，这可能是有些译作将working memory译为工作内存的缘故，为避免混淆，这里称其为工作存储，每个线程都有自己的工作存储）中进行，不能直接从相互内存中读写
所以说以上的那个程序,子线程一直从自己的工作内存里取出isStop的变量副本,一直无法发现共享内存里已经改变了值.
普遍的解决方法是,对isStop声明了volatile变量,这样,对变量的读写都会从共享内存里去取,而不是从工作内存(缓存)里拿.
volatile的语义就是在该变量被修改的时候,不使用线程的缓存,(这里的缓存指的可能是寄存器或者是cpu的1,2,3级高速缓存).直接从共享内存(ram)里取出值.
那么除了将isStop声明为volatile变量,还有其他方法能避免线程使用缓存吗?
误打误撞,发现如果在死循环中打印或者进行wait的话,这个死循环会退出.就是说在进行吃i/0输出或者等待的时候导致了缓存失效?
稍微改改代码:
public class VolatileTest implements Runnable{
private boolean isStop;
public static void main(String[] args) {
// TODO Auto-generated method stub
VolatileTest v = new VolatileTest();
for(int i = 0 ; i < 1 ; i++){
Thread t = new Thread(v,"线程" + i);
t.start();
}
try{
Thread.sleep(1000);
}catch(Exception e){
}
v.isStop = true;
}
public void run() {
while(!isStop){
try {
//休眠足够时间,好去看看对应进程里线程在干啥
Thread.currentThread().sleep(30000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("停止");
}
}
打印出的线程状态:
"线程0" #9 prio=5 os_prio=0 tid=0x00007f818c0dd800 nid=0x1968 waiting on condition [0x00007f816dedb000]
java.lang.Thread.State: TIMED_WAITING (sleeping)
at java.lang.Thread.sleep(Native Method)
at cn.senninha.swordtooffer.thread.VolatileTest.run(VolatileTest.java:22)
at java.lang.Thread.run(Thread.java:745)
似乎可以得出结论,一旦线程进入等待,缓存就会失效,然后就会从共享内存(ram)里去取值.
扯远了,所以volatile的特性就是:
1.可见性:对于volatile变量的读,总是看到任意线程对这个volatile变量最后的写入:
就是说,a线程如果对一个volatile变量进行了写入,那么其他线程对于该volatile变量的缓存就会失效,转而从共享内存里去获取这个变量最新的值.
2.原子性:对单个volatile变量的读写具有原子性
另外,只要对一个变量用volatile声明,不管它是多复杂的一个类,他的所有变量经过修改后都会马上写回共享内存里,保证可见性,比如如下示例:
/**
*声明VolatileNode为volatile变量,实际上用来通信表示线程需要停止的是VolatileNode对象里
*的VolatileNode1里的isStop变量,但是,在这种情况下,isStop的改变仍然会马上写回共享内存
*里,保证可见性.所以,在声明volatile变量时候,粒度应该尽量小一点,不然应该会影响到效率.
**/
public class VolatileTest implements Runnable{
private boolean isStop;
private volatile VolatileNode node = new VolatileNode();
public static void main(String[] args) throws InterruptedException {
// TODO Auto-generated method stub
VolatileTest v = new VolatileTest();
for(int i = 0 ; i < 1 ; i++){
Thread t = new Thread(v,"线程" + i);
t.start();
}
Thread.currentThread().sleep(1000);
v.node.node1.isStop = true;
}
public void run() {
while(!node.node1.isStop){
}
System.out.println("停止");
}
}
class VolatileNode{
public boolean isStop;
public VolatileNode1 node1 = new VolatileNode1();
}
class VolatileNode1{
public boolean isStop;
}
