原创

死磕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修饰的变量,赋值后多执行了一个 load addl $0x0,(%esp) 操作,这个操作相当于一个内存屏障(指令重排序时不能把后面的指令重新排序到内存屏障之前的位置),只有一个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

正文到此结束