Java多线程之可见性之volatile

可见性

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

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

  • 线程交叉执行
  • 指令重排序加上线程交叉执行
  • 共享变量更新后的值没有在工作内存与主存间及时更新
  • 保证可见性和原子性

对于可见性Java提供了synchonizedvolatile

volatile

通过加入内存屏障和禁止重排序优化来实现,保证可见性不保证原子性
volatile变量进行写操作时,会在写操作后加入一条store屏障指令,将工作内存变量值刷新到主内存。

图片alt

volatile变量进行读操作时,会在读操作前加入一条load屏障指令,从主内存读取共享变量。

图片alt

通过上面两点,任何时候,不同线程总能看到该变量的最新值.所有的操作都是CPU级别的。

并不是说使用了volatile就线程安全了

  1. package com.keytech.task;
  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  4. import java.util.concurrent.Semaphore;
  5. public class VolatileTest {
  6. private static Integer clientTotal=5000;
  7. private static Integer threadTotal=200;
  8. private static volatile Integer count=0;
  9. public static void main(String[] args) {
  10. ExecutorService executorService = Executors.newCachedThreadPool();
  11. Semaphore semaphore=new Semaphore(threadTotal);
  12. for (int i = 0; i < clientTotal; i++) {
  13. executorService.execute(()->{
  14. try{
  15. semaphore.acquire();
  16. update();
  17. semaphore.release();
  18. }catch (Exception e){
  19. e.printStackTrace();
  20. }
  21. });
  22. }
  23. executorService.shutdown();
  24. System.out.println("count:"+count);
  25. }
  26. private static void update(){
  27. count++;
  28. }
  29. }
  30. //count:4988

虽然使用了volatile,但是线程不安全。原因:update是非原子性的。

  1. private static void update() {
  2. count++; //分3步
  3. //1.取出当前count值
  4. //2.count + 1
  5. //3.count 重新写回主存
  6. }

假设同时有两个线程进行操作,两个线程同时执行到第一步(从内存中读取最新值)得到一样的最新的结果,然后进入第二步(+1操作)并进行第三步(从新写回主存)。尽管第一步获取的值是一样的,但是同时将+1后的操作写回主存,这样就会丢掉某个+1的操作,这样就会出现线程不安全问题

总结

  • volatile进行多线程加是线程不安全的,不适合计数
  • volatile不具备原子性

volatile的使用场景

  • 对变量的写操作不依赖当前值
  • 该变量没有包含在其它变量的不变式子中
  • volatile适合作为状态的标记量
  1. volatile boolean flag = false;
  2. //线程1
  3. context = loadContext();
  4. flag = true;
  5. //线程2
  6. while(!flag){
  7. sleep();
  8. }
  9. todo(context);

返回笔记列表
入门小站