Java多线程中变量的可见性

之所以写这篇博客, 是因为在csdn上看到一个帖子问的就是这个问题. 废话不多说, 我们先看看他的代码(为了减少代码量, 我将创建线程并启动的部分修改为使用方法引用).

1234567891011121314151617181920212223242526272829303132333435363738

public class ProductAndComsuer {    private int i = 0;    private Object lock = new Object();  //锁    private boolean created = false;   //用以判断是否有产品被消费    public void create(){        while(true){            if(!created){  //说明没有产品了，需要生产                synchronized(lock){                    System.out.println(Thread.currentThread().getName() + ":生产线程-->" + i++);                    created = true;                    System.out.println("created-->" + created);                }            }        }    }    public void consume(){        while(true){            if(created){                synchronized(lock){                    System.out.println(Thread.currentThread().getName() + ":消费线程-->" + i);                    created = false;                    System.out.println("created-->" + created);                }            }        }    }    public static void main(String[] args) {        final ProductAndComsuer pClass = new ProductAndComsuer();        new Thread(pClass::create).start();        new Thread(pClass::consume).start();    }}

这是学习多线程非常典型的生产者消费者. 那么这段代码有问题吗? 为什么输出几行以后就不动了呢?是死锁了吗? 这里我们先复习一下死锁的定义和产生条件.

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

而出现死锁必然满足四个条件:

互斥条件.
请求和保持条件
不剥夺条件
环路等待条件

再看看这个程序, 第二条就不满足: 一个线程同一时间只会处于保持锁或者请求锁的状态, 根本就没有出现请求和保持同时出现的情况. 换(shuo)句(ju)话(ren)说(hua), 这里只有一个锁, 怎么可能发生死锁呢? 要证明这一点很简单, 只需要在两个线程的while和if之间加一句打印的语句就知道了. 比如create方法中:

1234567891011

while(true) {    System.out.println("create方法, created=" + created + ", 是否满足条件?" + (!created) );    if(!created) {        synchronized(lock) {            // 为了方便查看信息, 这里的输出语句注释掉            // System.out.println(Thread.currentThread().getName()+":生产线程-->"+i++);            created = true;            // System.out.println("created-->"+created);        }    }}

在编译运行程序, 就会发现程序并没有死锁, 那么为什么程序就是不执行同步块中的程序呢? 仔细看一下刚才程序的输出就知道原因了

create方法, created=true, 是否满足条件?falsecreate方法, created=true, 是否满足条件?falseconsume方法, created=false, 是否满足条件?falseconsume方法, created=false, 是否满足条件?false

我们发现不管是create方法还是consume方法, 都不满足进入if语句的条件. 怎么会这样呢? create方法明明将created赋值为true了. 其实, 单独看create方法和consume方法是看不出问题的. 这两个方法很正确. 问题其实是出在多线程中变量的可见性上. 在《JAVA并发编程实践》(点击查看豆瓣评价)3.1节中说:

在没有同步的情况下, 编译器, 处理器, 运行时安排操作的执行顺序可能完全出人意料. 在没有进行适当同步的多线程程序中, 尝试推断那些”必然”发生在内存中的动作时, 你总是会判断错误.

换句话说, 即使create方法将created赋值为true, 如果没有适当的同步, 那么consume方法中看见的可能还是以前的false. 同样, create方法看到的也可能是以前的值. 结果, 两个方法就都无法进入自己的if语句块了.

更糟糕的是, 过期情况并不一定会马上发生, 也不一定会发生在所有的变量上, 当然也不会完全不出现. 所以就有可能被忽略.

volatile关键字是干什么的呢? 上面也说了, 过期情况只会发生在没有适当同步的多线程程序中. 说道同步, 首先想到的应该就是加锁了吧. 但是加锁的开销太大, 而且不合适的锁会导致基本上线性执行的多线程程序(就像这个例子中的程序). 那么有没有其他的方法呢? 那就得靠volatile了.

《JAVA并发编程实践》中是这样说的:

Java语言也提供了其他的选择, 及一种同步的弱形式: volatile变量. 它确保对一个变量的更新会以可预见的方式告知其他的线程.
…
所以, 读一个volatile类型的变量时, 总会返回由某一线程所写入的最新值.

也就是说, 我们只需要将create变量的声明前添加volatile关键字即可解决问题:

1	`private volatile boolean created = false;`

另外, 需要注意《JAVA并发编程实践》里面还说到:

当验证正确性必须推断可见性问题时, 应该避免使用volatile变量. 正确使用volatile变量的方式包括: 用于确保他们所引用的对象状态的可见性, 或者用于标示重要的生命事件(比如初始化或者关闭)的方法

也就是说, volatile虽好, 但不能到处随意的使用. 可能是因为volatile容易用错, 所以这个关键字比较低调, 很多地方都没有提过这个关键字. 简单的说, 因为volatile不能提供原子性, 所以使用volatile的变量的所有读取/修改必须是原子修改, 比如x++就不是, 因为是先读取又写入. 这里我们就不深入说了, 要了解更多信息可以翻翻《JAVA并发编程实践》或者看看这篇”文档”《Java 理论与实践: 正确使用 Volatile 变量》.

最后, 我们再说说如何使用同步块解决这个问题. 其实很简单, 只需要将同步块和if语句对调即可:

1234567891011121314151617181920212223

 private int i = 0;    private Object lock = new Object();  //锁    private boolean created = false;   //用以判断是否有产品被消费    public void create(){        while(true){            synchronized(lock){ // 先加锁, 再判断                if(!created){                    ...                }            }        }    }    public void consume(){        while(true){            synchronized(lock){                if(created){                    ...                }            }        }    }

分类: 编程语言标签: java, 多线程
原创作者:BK.转载请注明出处. 原文地址: http://iamlbk.github.io/blog/20160109/java-thread-visibility/
2016年01月09日 6:52 pm