C 语言中的 volatile 关键字

news2025/4/19 0:18:44

1、概念

volatile 是 C/C++ 语言中的一个类型修饰符，用于告知编译器：该变量的值可能会在程序控制流之外被意外修改（如硬件寄存器、多线程共享变量或信号处理函数等），因此编译器不应对其进行激进的优化（如缓存到寄存器或消除冗余读取）。

在程序运行时，编译器通常会假设变量的值仅由当前线程或函数内的代码修改，并据此进行优化（如循环内变量提升、指令重排等）。然而，在嵌入式开发、设备驱动编程或多线程环境中，某些变量的值可能被外部因素（如硬件中断、信号处理器、其他线程）异步修改。此时，若未使用 volatile 修饰，编译器可能生成错误的优化代码，导致程序行为异常。

简而言之，volatile 的作用是：

阻止编译器优化：强制每次访问变量时都从内存读取，而非使用寄存器中的缓存值；
确保内存可见性：防止编译器重排或省略对变量的访问，保证操作顺序符合预期；
适用于特殊场景：如硬件寄存器映射、信号处理、多线程共享变量（需配合其他同步机制）

volatile 并不解决所有并发问题（如原子性），但它是底层编程中确保正确内存访问的重要工具。

2、代码测试

下面是在 ARM 平台的 C 语言测试，因为 ARM 是弱内存模型，更容易复现问题。

/*
 *  volatile_test.c
 */

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

// 全局变量，使用或不使用volatile修饰
int flag = 0;  // 尝试改为 volatile int flag = 0; 观察不同结果

void handler(int sig) {
    flag = 1;
    printf("Signal handler set flag to 1\n");
}

int main() {
    signal(SIGALRM, handler);
    alarm(1);  // 1秒后发送SIGALRM信号

    while(!flag) {
        // 空循环等待flag变化
    }

    printf("Main loop detected flag change\n");
    return 0;
}

2.1 测试结果

不使用 volatile 关键字，程序会卡死在 while 循环中：

liang@liang-virtual-machine:~/cfp$../arm-none-linux-gnueabi-gcc -O3 -g -o volatile_test volatile_test.c
liang@liang-virtual-machine:~/cfp$ ./volatile_test
Signal handler set flag to 1

使用 volatile，程序正常退出

liang@liang-virtual-machine:~/cfp$../arm-none-linux-gnueabi-gcc -O3 -g -o volatile_test volatile_test.c
liang@liang-virtual-machine:~/cfp$ ./volatile_test
Signal handler set flag to 1
Main loop detected flag change
liang@liang-virtual-machine:~/cfp$

2.2 反汇编

不使用 volatile：

liang@liang-virtual-machine:~/cfp$../arm-none-linux-gnueabi-objdump -S volatile_test
......
int main() {
    83cc:	e92d4010 	push	{r4, lr}
    signal(SIGALRM, handler);
    83d0:	e59f1030 	ldr	r1, [pc, #48]	; 8408 <main+0x3c>
    83d4:	e3a0000e 	mov	r0, #14	; 0xe
    83d8:	ebffffc5 	bl	82f4 <_init+0x38>
    alarm(1);  // 1秒后发送SIGALRM信号
    83dc:	e3a00001 	mov	r0, #1	; 0x1
    83e0:	ebffffc9 	bl	830c <_init+0x50>
    83e4:	e59f3020 	ldr	r3, [pc, #32]	; 840c <main+0x40>
    83e8:	e5932000 	ldr	r2, [r3]		      ; 从内存读取 flag 值到 r2
    83ec:	e3520000 	cmp	r2, #0	; 0x0		  ; 比较 r2 的值
    83f0:	1a000000 	bne	83f8 <main+0x2c>	  ; 如果 r2≠0，跳转到 83f8 位置
    83f4:	eafffffe 	b	83f4 <main+0x28>      ; 无条件跳转到自身(无限循环)

    while(!flag) {
        // 空循环等待flag变化
    }

    printf("Main loop detected flag change\n");
    83f8:	e59f0010 	ldr	r0, [pc, #16]	; 8410 <main+0x44>
    83fc:	ebffffc5 	bl	8318 <_init+0x5c>
    return 0;
}
......

可以看到，编译器对 while 循环做了优化。编译器只在循环开始前读取一次 flag 的值到寄存器 r2。编译器认为 flag 在循环内不会被修改，之后循环中不再重新从内存读取 flag。同时，直接做了一个无条件跳转到自身的优化：

83f4:	eafffffe 	b	83f4 <main+0x28>      ; 无条件跳转到自身(无限循环)

而对比使用 volatile 关键字，可以看到编译器没有对 while 循环做优化，每次循环都重新读取 flag 的值：

liang@liang-virtual-machine:~/cfp$../arm-none-linux-gnueabi-objdump -S volatile_test
......
int main() {
    83cc:	e92d4010 	push	{r4, lr}
    signal(SIGALRM, handler);
    83d0:	e59f102c 	ldr	r1, [pc, #44]	; 8404 <main+0x38>
    83d4:	e3a0000e 	mov	r0, #14	; 0xe
    83d8:	ebffffc5 	bl	82f4 <_init+0x38>
    alarm(1);  // 1秒后发送SIGALRM信号
    83dc:	e3a00001 	mov	r0, #1	; 0x1
    83e0:	ebffffc9 	bl	830c <_init+0x50>
    83e4:	e59f201c 	ldr	r2, [pc, #28]	; 8408 <main+0x3c>

    while(!flag) {
    83e8:	e5923000 	ldr	r3, [r2]			; 每次循环都重新读取flag
    83ec:	e3530000 	cmp	r3, #0	; 0x0		; 如果≠0跳转到退出
    83f0:	0afffffc 	beq	83e8 <main+0x1c>	; 继续循环
        // 空循环等待flag变化
    }

    printf("Main loop detected flag change\n");
    83f4:	e59f0010 	ldr	r0, [pc, #16]	; 840c <main+0x40>
    83f8:	ebffffc6 	bl	8318 <_init+0x5c>
    return 0;
}
......