[Java高并发系列(2)]Java中volatile关键字详解 + volatile与sychronized区别

[Java高并发系列(2)]Java 中 volatile 关键字详解 + volatile 与 sychronized 区别

1 几个概念

1.1 可见性

通常，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。

可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的.也就是一个线程修改的结果。另一个线程马上就能看到。

比如：用volatile修饰的变量，就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即直接修改内存。所以对其他线程是可见的。

但是这里需要注意一个问题，volatile只能让被他修饰内容具有可见性，但不能保证它具有原子性。比如 volatile int a = 0;之后有一个操作 a++;这个变量a具有可见性，但是a++ 依然是一个非原子操作，也就是这个操作同样存在线程安全问题。

Java 中 volatile、synchronized 和 final 实现可见性。

1.2 原子性

**程序的原子性指:整个程序中的所有操作,要么全部完成,要么全部不完成,不可能停滞在中间某个环节(不可分割)。**比如 a=0；（a非long和double类型） 这个操作是不可分割的，那么我们说这个操作时原子操作。再比如：a++； 这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。比如：AtomicInteger、AtomicLong、AtomicReference等。

Java 中 synchronized 和在 lock、unlock 中操作保证原子性。

1.3 有序性

Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性.

1. volatile 是因为其本身包含“禁止指令重排序”的语义.
2. synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。

2 volatile关键字介绍

使一个变量在多个线程间可见.

比如: ＡＢ线程都用到一个变量,　java默认是Ａ线程中保留一份copy,这样如果B线程修改了该变量,则A线程未必知道

​ 使用volatile 关键字 ,会让所有线程都会读到变量的修改值

看一个例子 e.g.1

import java.util.concurrent.TimeUnit;

public class T {
     /*volatile*/   boolean running = true ;    //对比一下有无volatile的情况下, 整个程序运行结果的区别
    //volatile 保证线程之间的可见性, 当主线程把把running值修改后 通知了t1线程去读新的running的值
    void m (){
        System.out.println("m start");
        while (running){
        	// 可能有其他操作
        }
        System.out.println("m end !!!");
    }

    public static void main(String[] args) {
        T t = new T();
        
        new Thread(()->t.m(), "t1").start();	//lambda表达式, java8 特性,相当于如下:
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                t.m();
//            }
//        }, "t1").start();
        
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.running = false;
    	System.out.println(" main thread end! ");
    }

}

下面来分析分析e,g,1

a) running无volatile修饰时.

主线程实例化一个T对象t, 接着创建一个线程t1并执行. 线程中t调用m方法, running = true , 导致while进入死循环, 线程死死执行在这里.

当然主线程也能继续执行, 于是是可以看到 main thread end! 打印出来的… 但是发现线程t1 就一直执行占用资源了.

咦? 在main线程退出时 t.running 不是变为了false了吗? 难到t1 没有读到 ? 回答正确.

在 e.g.1 中, running是存在于堆内存的t对象中的 .当线程t1开始运行的时候, 会把running值从内存中读到t1线程的工作区, 在运行过程中直接使用这个copy , 并不会每次都去读取堆内存, 这样,当主线程修改running的值后,t1线程感知不到, 所以不会停止运行 . (那么是不是永远也不会去读最新的呢? 实际并不是, 但是在什么时候去读, 不太了解了)

b) running有volatile修饰时

使用volatile,将会强制所有线程都去堆内存中读取running的值, 这样当主线程将t . running改为false 后, t1读到 , 死循环停止, 继续执行后面的东西.

volatile不能替代synchronized

volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized

看下面这个例子

import java.util.ArrayList;
import java.util.List;

public class T {
    volatile int count = 0;
    void m() {
        for(int i=0; i<10000; i++) count++;
    }

    public static void main(String[] args) {
        T t = new T();

        List<Thread> threads = new ArrayList<Thread>();

        for(int i=0; i<10; i++) {
            threads.add(new Thread(t::m, "thread-"+i));
        }

        threads.forEach((o)->o.start());

        threads.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(t.count);
    }
}

说明:

T类中有一个volatile修饰的变量 count (因此它是可见的, 一个线程修改都会通知其他线程读), 然后一个m方法执行count ++ 10000次

主线程实例化一个T对象t, 接着创建了一个线程的ArrayList.

创建10个线程, 创建启动时会执行 t 的m方法, 即每个线程都count 10000次, 顺便加到threads数组中.

接着启动list中每个线程… 直到最后一个线程完成后, 主线程打印出现在的count值.

运行后可发现打印的结果并不是10000, 每次执行也可能不同 ,似乎也发生了线程安全问题.

volatile并不能保证多个线程共同修改同一个变量时所带来的不一致问题，也就是说volatile不能替代synchronized

3 volatile 关键字原理

Java语言提供了一种稍弱的同步机制,volatile变量,用来确保将变量的更新操作通知到其他线程.

当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的,因此不会将该变量上的操作与其他内存操作一起重排序.volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方,因此在读取volatile类型的变量时总会返回最新写入的值.

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pSrO7awS-1574298903178)(/home/lowfree/doc/notes/distributed/731716-20160708224602686-2141387366.png)]

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

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

当一个变量定义为 volatile 之后，将具备两种特性：

1. 保证此变量对所有的线程的可见性，这里的“可见性”，如本文开头所述，当一个线程修改了这个变量的值，volatile 保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。但普通变量做不到这点，普通变量的值在线程间传递均需要通过主内存（详见：Java内存模型）来完成。

2. 禁止指令重排序优化。有volatile修饰的变量，赋值后多执行了一个“load addl $0x0, (%esp)”操作，这个操作相当于一个内存屏障（指令重排序时不能把后面的指令重排序到内存屏障之前的位置），只有一个CPU访问内存时，并不需要内存屏障；
   （什么是指令重排序：是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理）

volatile 性能：

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