线程安全性（二） 可见性

可见性

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

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

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

JVM提供的2种处理可见性的方案

• synchronized
• volatile

JMM关于synchronized的两条规定；

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

volatile

• 关于内存屏障对重排序的保障：
  • 对volatile变量进行写操作时，会在写操作之前加StoreStore屏障，禁止上面的普通写和votalile写重排序；在volatile写操作之后加入一条StoreLoad屏障指令，禁止volatile写和下面有可能的读/写重排序；
  • 对volatile变量读操作时，会在读操作后加入一条LoadLoad屏障指令，禁止下面所有普通读和上面的votatile读重排序；接着插入LoadStore屏障指令，禁止下面所有写操作和上面volatile读重排序；
• 关于volatile对可见性的保障：
  • 对volatile变量的读，线程在私有内存中使用volatile变量副本的时候，会去主内存中查看volatile变量的最新值，如果最新值和线程私有内存中的volatile变量副本的值不一样，则会从主内存中重新load新值到线程私有内存中volatile变量副本中，从而保证可见性；
  • 对volatile变量的写，当线程私有内存中对volatile变量副本发生更改后，会立马写入主内存volatile变量中，从而保证可见性；

关于内存屏障

• 内存屏障首先是CPU指令级别的操作；
• 内存屏障的插入会产生两个效果
  • 内存屏障之前的更新，写入缓存；
  • 内存屏障之前的指令在内存屏障之前执行，内存屏障之后的指令在内存屏障之后执行，禁止了内存屏障上下的重排序；

关于volatile

• volatile保证了可见性，：volatile能保证线程取到的值是最新值（线程1对共享变量的修改会立马写回主内存，线程2在使用共享变量的时候，如果其私有拷贝已不是最新值，会从主内存中取回最新值），但其对值的操作不是原子性的，即在其操作值的时候，别的线程可以取到值并进行操作，即volatile保证的可见性能确保线程取到的值是最新的，但不能保证其在线程中对值的修改是原子性的；
• volatile禁止了指令重排，其实现手段是插入内存屏障：volatile修饰的变量禁止了指令重排，避免了因指令重排导致的在多线程之间出现的问题；
  • volatile禁止指令重排运场景一：线程1中的信号量对线程2的通知；
  • volatile禁止指令重排运场景二：单例模式的双重检查，new指令从字节码层面是3条指令；

示例1 - 对volatile修饰的变量的写操作不是原子性的

import com.example.concurrency.annotations.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到主内存
    }

}

输出：

• 线程1读到100，线程2读到100，线程1加1得101，线程2加1得101，线程1将101写回主内存，线程2将101写回主内存，导致丢失1次计数；

20:59:52.210 [main] INFO com.example.concurrency.example.count.CountExample4 - count:4974

votalile的使用须满足以下两个条件

• 对变量的写操作不依赖于当前值；
• 该变量没有包含在具有其他变量的不变的表达式中；

示例2 - volatile适用场景（一）状态标记量

• 如果inited没有标记成volatile，那么在线程1中inited = true;这行代码可能由于指令重排序的缘故，提前于最后一行执行；
• 如果发生了指令重排序，线程1对线程2的通知就会提前，从而造成可能出现的问题；
• 当inited被volatile标记后，volatile禁止了对inited的重排序，从而保证在线程1中inited = true;这句一定是在最后一行执行，从而保证线程1对线程2的通知是正确的；

public class VolatileDemo1 {

    public static volatile boolean inited = false;
    public static int var = 0;

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();

        service.execute(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(2);
                var = -1;
                inited = true;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        service.execute(() -> {
            while (!inited) {
                System.out.println(var++);
            }
            System.out.println(var);
        }); 

        service.shutdown();
    }

}

示例3 - volatile适用场景（二） DoubleCheck

C05 单例模式 懒汉式的线程安全问题及解决方案（二） 双重检查 & volatile

相关文章

聊聊并发（一）——深入分析 Volatile 的实现原理