并发编程与高并发解决方案（二）：可见性volatile

可见性

一个线程对主内存的修改可以及时的被其他线程观察到

共享变量在线程间不可见的原因

• 线程交叉执行
• 重排序结合线程交叉执行
• 共享变量更新后的值没有在工作内存与主内存间及时更新

Synchronized

synchronized能够实现原子性和可见性 。
JMM关于其的规定 ：锁可以让临界区互斥执行，让释放锁的线程向获取同一个锁的线程发送消息。

• 线程解锁前，必须把共享变量的最新值刷新到主内存
• 线程加锁时，清空工作内存中共享变量的值，从而使用共享变量时需要从主内存重新读取最新值【注意，加锁和解锁必须是同一把锁】

可见性-volatile

通过 加入内存屏障和 禁止重排序优化来实现

//对一个 volatile 域的写, happens-before 于任意后续对这个 volatile 域的读
public class ReorderExample {
    private int x = 0;
    private int y = 1;
    private volatile boolean flag = false;
    public void writer(){
        x = 42;    //1
        y = 50;    //2
        flag = true;    //3
    }
    public void reader(){
        if (flag){    //4
            System.out.println("x:" + x);    //5
            System.out.println("y:" + y);    //6
        }
    }
}

• 对volatile变量写时，

  • 会在volatile写操作前加入一条storestore屏障
  • 会在volatile写操作后加入一条storeLoad屏障;
    将本地内存中的共享变量值刷新到主内存
    
    volatile 写之前的操作不会被重排序到 volatile 写之后
    代码 1 和 2 不会被重排序到代码 3 的后面，但代码 1 和 2 可能被重排序 (没有依赖也不会影响到执行结果)

• 对volatile变量读操作时，

  • 在volatile读后加入LoadLoad、Loadstore屏障指令，将主内存中共享变量读出
    
    确保了 volatile 读之后的操作不会被重排序到 volatile 读之前
    代码 4 是读取 volatile 变量，代码 5 和 6 不会被重排序到代码 4 之前

import com.mmall.concurrency.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;
 
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
 
@Slf4j
@NotThreadSafe
public class CountExample4 {
    // 请求总数
    public static int clientTotal = 5000;
    // 同时并发执行的线程数
    public static int threadTotal = 200;
    public static volatile int count = 0;
    
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count);
    }
 
    private static void add() {
        count++;
        // 1、取内存中的count
        // 2、count值+1
        // 3、count写回主存
        //对线程同时交叉执行2、3，导致结果不正确。
    }
}

volatile本质是在告诉JVM当前变量在寄存器中的值是不确定的，使用前，需要先从主存中读取，因此可以实现可见性。而对n=n+1,n++等操作时，volatile关键字将失效，不能起到像synchronized一样的线程同步（原子性）的效果。

volatile 使用场景

volatile 只能保证顺序不会被重排序，但不能保证其原子执行。
对任意单个volatile变量的读/写具有原子性，但类似volatile++的复合操作不具有原子性。

使用条件：

1. 对变量写操作不依赖于当前值。
2. 该变量没有包含在具有其他变量的不变式中。

特别适合做线程标记量 volatile boolen inited = false;

第一个条件的限制使 volatile 变量不能用作线程安全计数器。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供必须的原子特性。
实现正确的操作需要使 x 的值在操作期间保持不变，而 volatile 变量无法实现这点。

大多数编程情形都会与这两个条件的其中之一冲突，使得 volatile 变量不能像 synchronized 那样普遍适用于实现线程安全。

//状态标记伪代码
volatile boolean inited = false;
//线程A
context = loadContext();
inited = true;
//线程B
while(!inited){
sleep();
}
doSomethingWithConfig(context)

将inited 标记为 volatile ， 当线程A更新inited后，因为是volatile，所以线程B可以及时从主内存中感知到inited的改变。 这样就确保了线程B中使用的contex是初始化过的。

synchronized和volatile的比较

synchronized保证内存可见性和操作的原子性
volatile只能保证内存可见性
volatile不需要加锁，比synchronized更轻量级，并不会阻塞线程
volatile标记的变量不会被编译器优化,而synchronized标记的变量可以被编译器优化（如编译器重排序的优化）.
volatile是变量修饰符，仅能用于变量，而synchronized是一个方法或块的修饰符。