⼤
⽩
话
聊聊
Java
并
发
⾯
试
问题
之
volatile
到
底
是
什么
？
作
者
:
中
华
⽯
杉
原
⽂
地址
⼀
、
写
在
前
⾯
前
段
时
间
把
⼏
年
前
带
过
的
⼀个
项
⽬
架构
演
进
的
过
程
整
理
了
⼀个
系
列出
来
，
参
⻅
（
《
亿
级
流
量
架
构
系
列
专
栏
总
结
》
）
。
不
过
很
多
同
学
看
了之
后
，
后台反
馈
说
⽂
章
太
烧
脑
，
看的
云
⾥
雾
⾥
。
其
实
这
个
也
正
常
，
⽂
章
承
载
的
信
息
毕
竟
有
限
，
⽽
架构
的
东
⻄
细
节
太多
，
想
要
仅仅
通过
⽂
章
看
懂
⼀个
系统
架构
的
设计
和
落
地
，
确
实
难
度
不
⼩
。
所
以
接
下
来
⽤
⼤
⽩
话
跟
⼤
家
聊
点
轻
松
的
话
题
，
⽐
较
易
于
理
解
，
⽽
且
对
⼤
家⼯
作
和
⾯
试
都
很
有
帮
助
。
⼆
、
场
景
引
⼊
，
问题
初
现
很
多
同
学
出
去
⾯
试
，
都
会
被
问
到
⼀个
常
⻅
的
问题
：
说说
你
对
volatile
的
理
解
？
不
少
初出
茅
庐
的
同
学
可
能
会
有
点
措
⼿
不
及
，
因
为
可
能
就
是
之
前
没
关
注
过这
个
。
但
是
⽹
上
百
度
⼀
下
呢
，不
少
⽂
章
写
的
很
好
，
但
是
理
论
扎
的
太
深
，
⽂
字
太多
，
图
太
少
，
让
⼈
有
点
难
以
理
解
。
基
于
上
述
痛
点
，
这
篇
⽂
章
尝
试
站
在
年
轻
同
学
的
⻆
度
，
⽤
最
简
单
的
⼤
⽩
话
，
加
上
多
张
图
给
⼤
家
说
⼀下，
volatile
到
底
是
什么
？
当
然
本
⽂
不
会
把
理
论
扎
的
太
深
，
因
为
⼀下
⼦
扎
深
了
⽂
字
太多
，
很
多
同
学
还
是
会
不
好
理
解
。
本
⽂
仅仅
是
定
位
在
⽤
⼤
⽩
话
的
语⾔
将
volatile
这
个东
⻄解
释
清
楚
，
⽽
涉
及
到
特
别
底
层
的
⼀
些
原
理
和
技
术
问题
，
以
后
有机
会
开
⽂
再写
。
⾸
先
，
给
⼤
家
上⼀
张
图
，
咱
们
来
⼀
起
看看
：
公众号：石杉的架构笔记
如
上
图
，
这
张
图
说
的
是
java
内
存
模
型
中
，
每
个
线
程
有
⾃
⼰
的
⼯
作
内
存
，
同
时
还
有
⼀个
共
享
的
主
内
存
。
举
个
例
⼦
，
⽐
如
说
有
两个
线
程
，
他们
的
代
码
⾥
都
需
要读
取
data
这
个
变
量
的
值
，
那
么他们
都
会从
主
内
存
⾥
加
载
data
变
量
的
值
到
⾃
⼰
的
⼯
作
内
存
，
然
后
才
可
以使
⽤
那
个
值
。
好
了
，
现
在
⼤
家
从
图
⾥
看
到
，
每
个
线
程
都
把
data
这
个
变
量
的
副
本
加
载
到
了
⾃
⼰
的
⼯
作
内
存
⾥
了
，
所
以
每
个
线
程
都
可
以
读
到
data = 0
这
个
值
。
这
样
，
在
线
程
代
码
运
⾏
的
过
程
中
，
对
data
的
值
都
可
以
直
接
从
⼯
作
内
存
⾥
加
载
了
，不
需
要
再
从主
内
存
⾥
加
载
了
。
那
问题
来
了
，
为
啥
⼀
定
要让
每
个
线
程
⽤
⼀个
⼯
作
内
存
来
存
放
变
量
的
副
本
以供
读
取呢
？
我
直
接
让
线
程
每次
都
从主
内
存
加
载
变
量
的
值
不
⾏
吗
？
很
简
单
！
因
为
线
程
运
⾏
的
代
码
对
应
的
是
⼀
些
指
令
，
是
由
CPU
执
⾏
的
！
但
是
CPU
每次
执
⾏
指
令
运
算
的
时
候
，
也
就
是
执
⾏
我
们
写
的
那
⼀
⼤
坨
代
码的
时
候
，
要
是
每次
需
要
⼀个
变
量
的
值
，
都
从主
内
存
加
载
，
性
能
会
⽐
较
差
！
所
以
说
后
来
想
了
⼀个
办
法
，
就
是
线
程
有
⼯
作
内
存
的
概
念
，
类
似于
⼀个
⾼
速
的
本
地
缓
存
。
这
样
⼀
来
，
线
程
的
代
码
在
执
⾏
过
程
中
，
就
可
以
直
接
从
⾃
⼰
本
地
缓
存
⾥
加
载
变
量
副
本
，不
需
要
从
主
内
存
加
载
变
量
值
，
性
能
可
以
提
升
很
多
！
但
是
⼤
家
思
考
⼀下，
这
样
会
有
什么
问题
？
我
们
来
设
想
⼀下，
假
如
说
线
程
1
修
改
了
data
变
量
的
值
为
1
，
然
后
将
这
个
修
改
写⼊
⾃
⼰
的
本
地
⼯
作
内
存
。
那
么
此
时
，
线
程
1
的
⼯
作
内
存
⾥
的
data
值
为
1
。
公众号：石杉的架构笔记
然
⽽
，
主
内
存
⾥
的
data
值
还
是
为
0
！
线
程
2
的
⼯
作
内
存
⾥
的
data
值
还
是
0
啊
？！
这
可
尴尬
了
，
那
接
下
来
，
在
线
程
1
的
代
码
运
⾏
过
程
中
，
他
可
以
直
接
读
到
data
最
新
的
值
是
1
，
但
是
线
程
2
的
代
码
运
⾏
过
程
中
读
到
的
data
的
值
还
是
0
！
这
就导
致
，
线
程
1
和
线
程
2
其
实
都
是
在
操
作
⼀个
变
量
data
，
但
是
线
程
1
修
改
了
data
变
量
的
值
之
后
，
线
程
2
是
看
不
到
的
，⼀
直
都
是
看
到
⾃
⼰
本
地
⼯
作
内
存
中
的
⼀个
旧
的
副
本
的
值
！
这
就
是
所
谓
的
java
并
发
编
程
中
的
可
⻅
性
问题
：
多
个
线
程
并
发
读
写
⼀个
共
享
变
量
的
时
候
，
有
可
能
某
个
线
程
修
改
了
变
量
的
值
，
但
是
其
他
线
程
看
不
到
！
也
就
是
对
其
他
线
程
不
可
⻅
！
三
、
volatile
的
作
⽤
及
背
后
的
原
理
那
如
果
要解
决
这
个
问题
怎
么
办
呢
？
这
时
就
轮
到
volatile
闪
亮
登
场
了
！
你
只
要
给
data
这
个
变
量
在
定
义
的
时
候
加
⼀个
volatile
，
就
直
接
可
以
完
美
的
解
决
这
个
可
⻅
性
的
问题
。
⽐
如
下
⾯
的
这
样
的
代
码
，
在
加
了
volatile
之
后
，
会
有
啥
作
⽤
呢
？
公众号：石杉的架构笔记
完
整
的
作
⽤
就
不
给
⼤
家
解
释
了
，
因
为
我
们
定
位
就
是
⼤
⽩
话
，
要
是
把
底
层
涉
及
的
各
种
内
存屏
障
、
指
令
重
排
等
概
念
在
这
⾥
带
出
来
，不
少
同
学
⼜
要
蒙
圈
了
！
我
们
这
⾥
，
就
说说
他
最
关
键
的
⼏
个
作
⽤
是
啥
？
第
⼀，⼀
旦
data
变
量
定
义
的
时
候
前
⾯
加
了
volatile
来
修
饰
的
话
，
那
么
线
程
1
只
要
修
改
data
变
量
的
值
，
就
会
在
修
改
完
⾃
⼰
本
地
⼯
作
内
存
的
data
变
量
值
之
后
，
强
制
将
这
个
data
变
量
最
新
的
值
刷
回
主
内
存
，
必
须
让
主
内
存
⾥
的
data
变
量
值
⽴
⻢
变
成
最
新
的
值
！
整
个
过
程
，
如
下
图
所
示
：
第
⼆
，
如
果
此
时
别
的
线
程
的
⼯
作
内
存
中
有
这
个
data
变
量
的
本
地
缓
存
，
也
就
是
⼀个
变
量
副
本
的
话
，
那
么会
强
制
让
其
他
线
程
的
⼯
作
内
存
中
的
data
变
量
缓
存
直
接
失
效
过
期
，不
允
许
再
次
读
取和
使
⽤
了
！
整
个
过
程
，
如
下
图
所
示
：
公众号：石杉的架构笔记
评论0