死磕java中的volatile关键字

volatile简介

volatile在英语词典中的释义有：不稳定的、反复无常的、易挥发的；简而言之，volatile就是表示某人或某物是不稳定的易变的。

volatile作为Java的关键词之一，用于声明变量的值可能随时会被别的线程修改，使用volatile修饰的变量会强制将修改的值立即写入主存，主存中值得更新会使缓存中的值失效，（非volatile修饰的变量则不具备这样的特性，非volatile变量的值会被缓存，线程A更新了这个值，线程B读取这个变量的值时可能读到的并不是线程A更新后的值）

volatile会禁止指令重排。

volatile原理

Java语言提供了一种稍弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者其他处理器不可见的地方，因此在读取volatile类型的变量时，总会返回最新写入的值。

在访问volatile变量时不会执行加锁操作，因此也就不会执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。

thread

当对非volatile变量进行读写的时候，每个线程先从内存拷贝变量的CPU缓存中。如果计算机有多个CPU，每个线程可能在不同的CPU上被处理，这意味着每个线程可以拷贝到不同的CPU cache中。

而声明变量是volatile的，JVM保证了每次变量都从内存中读取，跳过CPU cache这一步。

两种特性

  • 可见性，保证此变量对所有线程的可见性。正如以上描述，当一个线程修改了这个变量的值，volatile保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。而普通变量无法做到这一点。
  • 禁止指令重排序。有volatile修饰的变量，赋值后多执行了一个 <code style="color:red">load addl $0x0,(%esp)</code> 操作，这个操作相当于一个内存屏障（指令重排序时不能把后面的指令重新排序到内存屏障之前的位置），只有一个CPU访问内存时，并不需要内存屏障；（指令重排序：是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应的电路单元处理）

volatile性能

volatile的读性能与普通变量几乎相同，但是写操作稍慢，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。

volatile关键字代码示例

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰后，就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。示例代码：

public class TestWithoutVolatile {
    private static boolean bChanged;

    public static void main(String[] args) throws InterruptedException {
        new Thread(){
            @Override
            public void run() {
                for(;;){
                    if(bChanged == !bChanged){
                        System.out.println("! =");
                        System.exit(0);
                    }
                }
            }
        }.start();
        Thread.sleep(1000);
        new Thread(){
            @Override
            public void run() {
                for(;;){
                    bChanged =!bChanged;
                }
            }
        }.start();
    }
}

运行结果截图：

thread1

bChanged变量未加volatile关键字修饰，当其值被第二个线程改变后，不能立即被第一个线程得到，因此第一个线程中的循环将不会被中断。

bChanged变量加volatile关键字修饰后的代码：

public class TestWithoutVolatile {
    //volatile关键字修饰
    private static volatile boolean bChanged;

    public static void main(String[] args) throws InterruptedException {
        new Thread(){
            @Override
            public void run() {
                for(;;){
                    if(bChanged == !bChanged){
                        System.out.println("! =");
                        System.exit(0);
                    }
                }
            }
        }.start();
        Thread.sleep(1000);
        new Thread(){
            @Override
            public void run() {
                for(;;){
                    bChanged =!bChanged;
                }
            }
        }.start();
    }
}

运行结果截图：

thread2

bChanged变量加volatile关键字修饰，当其值被第二个线程改变后，立即被第一个线程得到，因此第一个线程中的循环将会被中断，输出 "! ="。

2）禁止指令重排序。

volatile保证原子性吗

从上面知道volatile关键字保证了操作的可见性，但是volatile能保证对变量的操作是原子性的吗？看下面的例子:

public class TestWithoutVolatile2 {
    public volatile int inc =0;

    public void increase(){
        inc ++;
    }

    public static void main(String[] args) {
        final TestWithoutVolatile2 test = new TestWithoutVolatile2();
        for (int i = 0; i < 10; i++) {
            new Thread(){
                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        test.increase();
                    }
                }
            }.start();
        }

        while (Thread.activeCount()>1){
            //保证前面的线程都执行完
            Thread.yield();
        }
        System.out.println(test.inc);
    }
}

运行截图：

例子1

按理说以上程序运行的结果是10000.但事实是每次运行的结果都不一致，且都是小于10000的数字。

也许有人会认为，由于volatile保证了可见性，那么在每个线程对Inc自增完之后，在其他线程中都能看到修改后的值，所以10个线程分别进行了1000次操作，那么最终的值应该是1000*10=10000

这里存在一个误区，volatile关键字能保证可见性，但是上面的程序没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。

自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行，就有可能导致下面这种情况出现：

假如某个时刻变量inc的值为10，
线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞；然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。然后线程1接着进行加1操作，由于已经读取了inc的值，注意此时在线程1的工作内存中inc的值仍然为10，所以线程1对inc进行加1操作后inc的值为11，然后将11写入工作内存，最后写入主存。

那么两个线程分别进行了一次自增操作后，inc只增加了1。

解释到这里，可能有朋友会有疑问，不对啊，前面不是保证一个变量在修改volatile变量时，会让缓存行无效吗？然后其他线程去读就会读到新的值，对，这个没错。这个就是上面的happens-before规则中的volatile变量规则，但是要注意，线程1对变量进行读取操作之后，被阻塞了的话，并没有对inc值进行修改。然后虽然volatile能保证线程2对变量inc的值读取是从内存中读取的，但是线程1没有进行修改，所以线程2根本就不会看到修改的值。

根源就在这里，自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。

如果需要得到原子性的效果，那么，开始改写代码。

  • 采用synchronized:

public class TestWithoutVolatile2 {
    public int inc =0;

    public synchronized void increase(){
        inc ++;
    }

    public static void main(String[] args) {
        final TestWithoutVolatile2 test = new TestWithoutVolatile2();
        for (int i = 0; i < 10; i++) {
            new Thread(){
                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        test.increase();
                    }
                }
            }.start();
        }

        while (Thread.activeCount()>1){
            //保证前面的线程都执行完
            Thread.yield();
        }
        System.out.println(test.inc);

    }
}

结果截图：

原子1
  • 采用Lock

public class TestWithoutVolatile2 {
    public int inc =0;
    Lock lock = new ReentrantLock();
    public void increase(){
        lock.lock();
        try{
            inc ++;
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        final TestWithoutVolatile2 test = new TestWithoutVolatile2();
        for (int i = 0; i < 10; i++) {
            new Thread(){
                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        test.increase();
                    }
                }
            }.start();
        }

        while (Thread.activeCount()>1){
            //保证前面的线程都执行完
            Thread.yield();
        }
        System.out.println(test.inc);

    }
}

运行截图

原子2
  • 采用AtomicInteger

public class TestWithoutVolatile2 {
    public AtomicInteger inc = new AtomicInteger();

    public void increase(){
        inc.getAndIncrement();
    }

    public static void main(String[] args) {
        final TestWithoutVolatile2 test = new TestWithoutVolatile2();
        for (int i = 0; i < 10; i++) {
            new Thread(){
                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        test.increase();
                    }
                }
            }.start();
        }

        while (Thread.activeCount()>1){
            //保证前面的线程都执行完
            Thread.yield();
        }
        System.out.println(test.inc);

    }
}

运行截图：

原子3
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 215,923评论 6赞 498
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,154评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 161,775评论 0赞 351
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,960评论 1赞 290
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,976评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,972评论 1赞 295
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,893评论 3赞 416
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,709评论 0赞 271
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,159评论 1赞 308
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,400评论 2赞 331
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,552评论 1赞 346
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,265评论 5赞 341
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,876评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,528评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,701评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,552评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,451评论 2赞 352

推荐阅读更多精彩内容