java中volatile关键词有什么作用？

最新推荐文章于 2025-06-06 20:43:57 发布

牟野

最新推荐文章于 2025-06-06 20:43:57 发布

阅读量579

点赞数

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： java

本文链接：https://blog.youkuaiyun.com/weixin_44906271/article/details/105884325

Java 专栏收录该内容

17 篇文章

订阅专栏

本文详细解析了Java中volatile关键字的三大特性：可见性、不保证原子性和禁止指令重排，通过具体实例展示了volatile如何在多线程环境中保障数据的一致性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

volatile关键字的特性

volatile是jvm提供的轻量级的同步机制

保证可见性
不保证原子性
禁止指令重排

什么是可见性：

java内存模型Java Memory Model，简称JMM，他是一种抽象的概念，并不真实存在，描述的是一组规则或规范，通过这种规范规定了了程序中各个变量的访问方式。

JVM运行程序的实体是线程，JVM为每一个线程分配了一个工作内存，工作内存是每个线程私有的。

JMM规定了所有变量都存储在主内存中（电脑的内存条），所有线程都可以访问主内存，但是线程对变量的读取赋值等操作必须在自己的工作内存中进行，所以首先要将变量拷贝到自己的工作内存，再对变量操作，操作完成后再将变量写回主内存。

每个线程的工作内存中都存储着主内存中变量的副本，线程之间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存。

如有三个线程同时访问主内存拿到了其中age变量的值为10，如果线程一将age的值重新赋值为20，操作完成后将age的值重新写回主内存，此时主内存中age的值改为了20，会通知线程二和线程三重新从主内存中拷贝新的age变量的值，这种一个线程改变了主内存的共享变量，别的线程马上就知道的特性，就叫可见性

测试示例：
VolatileDemo里定义的是普通int类型number，线程ThreadA会去改变VolatileDemo里的number值，主线程要是能检测到number值的变化，则会打破循环，打印"主线程执行完毕"语句

class VolatileDemo {
    int number = 0;

    public void addNum() {
        this.number = 60;
    }
}

public class Test {
    public static void main(String[] args) {
        VolatileDemo volatileDemo = new VolatileDemo();
        //ThreadA线程，开始执行后会等待3秒，3秒后会将number的值改为60
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "进程开始了");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            volatileDemo.addNum();
            System.out.println(Thread.currentThread().getName() + "更新数字number为" + volatileDemo.number);
        }, "ThreadA").start();

        //主线程，如果能够检测到VolatileDemo里的number值不为0了，那么循环就会打破，执行下面的打印语句
        while (volatileDemo.number == 0) {

        }
        System.out.println(Thread.currentThread().getName()+"主线程执行完毕");
    }
}

打印结果：
在这里插入图片描述

试试给number加上volatile关键词

   volatile int number = 0;

打印结果
在这里插入图片描述
可以看到主线程执行了打印语句，说明主线程检测到了number值的变化，为什么加上volatile关键词就能检测到呢，这就是所说的volatile保证了可见性

什么是原子性

原子性指的是某个线程正在做某个业务时，中间不可以被加塞或者被分割，需要整体完成，要么全部成功，要么要不失败
测试volatile不保证原子性

class VolatileDemo {
    volatile int number = 0;

    public void addPlusPlus() {
        number++;
    }
}

public class Test {
    public static void main(String[] args) {
        VolatileDemo volatileDemo = new VolatileDemo();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int i1 = 0; i1 < 1000; i1++) {
                    volatileDemo.addPlusPlus();
                }
            },String.valueOf(i)).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"number值为："+volatileDemo.number);
    }
}

打印结果：
在这里插入图片描述

可以看到这里的值都没有达到20000，而且每次的值都不一样，为什么呢？

这就是因为volatile关键词不保证原子性，所以当20个线程同时去修改主内存的值的时候，比如一个线程执行了一次addPlusPlus方法，number的值加了1，会马上把值写会到主内存中，然后别的线程就会拿到这个新的值开始自己的计算

但是如果A和B线程同时修改了值，A线程修改了之后，写回主内存，B线程只有重新拿到主线程的值，再进行计算，但是A和B是同时修改了，B修改了之后没有写回到主内存，反倒是重新从主内存中拿了一次数据回来，所以B线程刚刚的操作就丢失了，导致少了一次运算，这也就是为什么总的数值达不到2000，是因为中途丢失了太多操作了，当然也有可能能够达到20000，可能性比较低

如何解决不保证原子性？

使用synchronized关键词

    public synchronized void addPlusPlus() {
        number++;
    }

打印结果
在这里插入图片描述
可以达到我们的要求，但是synchronized是重量级锁，有没有轻量级的解决方案？
2. 使用AtomicInteger

class VolatileDemo {
    AtomicInteger atomicInteger = new AtomicInteger();

    public synchronized void addPlusPlus() {
        atomicInteger.getAndIncrement();
    }
}

public class Test {
    public static void main(String[] args) {
        VolatileDemo volatileDemo = new VolatileDemo();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int i1 = 0; i1 < 1000; i1++) {
                    volatileDemo.addPlusPlus();
                }
            },String.valueOf(i)).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"number值为："+volatileDemo.atomicInteger);
    }
}