欢迎关注我的微信公众号【Mflyyou】获取持续更新。
github.com/zhangpanqin/MFlyYou 收集技术文章及我的系列文章,欢迎 Star。
前言
java 中鼎鼎有名的 AQS
维护 private volatile int state
状态实现了用户态的锁。你如果不了解 volatile
,你看 AQS
的源码应该很难理解为什么 Lock
能保证共享变量线程安全。
volatile
绝对是你打通 java 的任督二脉的首要条件。votaile
的特性很简单,可见性
和 禁止指令重拍
,但是 volatile
并不能保证原子性,需要借助 cas 来保证原子性。
本文将会介绍如下内容:
volatile
的可见性是什么,有什么用volatile
禁止指令重排是个什么东东- 单例模式,饿汉式和懒汉式(DCL)的写法
- 伪共享是什么,怎么避免伪共享
volatile
可见性
![aab407b88f59868b2614d23d407852f9.png](https://i-blog.csdnimg.cn/blog_migrate/da9283abd66d0b99acd3d233211ac5d1.png)
计算机 CPU
与 主存
交互的逻辑大致如图,CPU
的运算速度是 主存
的 100 倍左右,为了避免 CPU
被主存拖慢速度。当CPU
需要一个数据的时候,会先从 L1
找,找到直接使用;L1
中未找到,会去 L2
中,L2
中找不到会去 L3
,L3 找不到再去主存加载到 L3
,再从 L3
加载到 L2
,再从 L2
加载到 L1
。为了避免每次加载运算数据都从主存中加载,Cpu
会将使用数据内存地址附近的数据也加载进来,因为通常内存分配是连续性的,目标数据附近的数据用到的可能性比较大。尽管可能浪费一部分存储空间,但是降低加载数据浪费的时间。这也就是以空间换时间。
多级缓存加载数据提高的计算速度,同时也面临数据不一致问题。
主存中现在有一个变量 a=1,CPU1
a+1 之后,将结果 a=2 放入到 L1
去,但是后续代码计算还会用到 a,这时 CPU1
不会将 a=2 同步到主存中去。之后 CPU2
也从主存中取出变量 a(a=1),CPU2
将 a+2 的结果放入到 L1
中。这样就造成了数据不一致问题。缓存一致性协议就是为了解决这个问题的。
缓存一致性协议
是在计算机层面保证数据的一致性。JAVA
在自己的虚拟机中执行,也有自己的内存模型 Java Memory Model (JMM)
,但不管怎么样,底层还是依靠的 CPU
指令集达到缓存一致性。JAVA 内存模型
屏蔽了不同操作系统(windows/linux/mac os)缓存一致性协议的不同实现细节,定义了 java 层面的接口,虚拟机要实现这个接口保证内存一致性。
![fe7c664adc02fdff1c39b839ffd4f9d3.png](https://i-blog.csdnimg.cn/blog_migrate/8dadc443f9c4a4a952baf01dec9ecfdc.png)
Java 内存模型规定所有的变量全部储存在主存中,每个线程都有自己的工作内存,工作内存中的变量是主存变量的副本拷贝(使用那些变量,拷贝那些),每个线程只会操作自己工作内存的变量,当需要保存数据一致性的时候,线程会将工作内存中的变量同步到主存中去,然后让用到这个变量的别的线程,从主存中重新读取最新变量到自己的工作内存中去。
接下来代码体会一下,带不带 volatile 的区别。
public class VolatileDemo {
private static int a = 0;
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
while (a == 0) {
}
}, "线程 1").start();
System.out.println("修改 a=1 之前");
Thread.sleep(3000);
a = 1;
System.out.println("修改 a=1 之后");
}
}
运行上面这个程序,代码会一直运行,不会停止。这是因为 线程1
的工作内存中 a 为 0 。尽管主线程修改了 a,但不会立刻将 a 同步到主存中去,同步到主存中去之后,也不会让别的线程感知到变量 a 已经变化了。由于 线程 1
始终认为 a 没有变化,所以程序会一直运行。
public class VolatileDemo {
// 代码的区别只是加了 volatile
private static volatile int a = 0;
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
while (a == 0) {
}
}, "线程 1").start();
System.out.println("修改 a=1 之前");
Thread.sleep(3000);
a = 1;
System.out.println("修改 a=1 之后");
}
}
代码的区别只是变量 a 加了 volatile
打印 修改 a=1 之后
程序停止。这是因为 volatile
标记的变量 a,主线程修改之后,并同步回主存,当其他的线程再使用变量 a 的时候,java 内存模型会让线程从主存重新加载变量 a。这就是 volatile
的 可见性
特点。只要 volatile 修饰的变量改变了,别的线程读取的时候立马感知到。
volatile
保证了写之后,任何读,都能读取到改变之后的值。(为了便于理解你也可以认为 :volatile 修饰的变量存放在主存中,但实际不是这个样子,还是放在线程的本地内存中。)
禁止指令重排
java 中的字节码最终都会编译成机器码(CPU 指令)执行,CPU 在保证单线程中执行结果不变的情况下,可以对指令进行指令重排已达到提高执行效率。
编译器再不影响执行结果的前提下,在编译的时候也可以对指令进行重排。
public class VolatileOrdering2 {
static int b = 1;
public static void main(String[] args) throws InterruptedException {
int a = 0;
b = 2;
a += 1;
System.out.println(a);
}
}
上述代码指令重排执行顺序的可能:
int a=0;
a+=1;
System.out.println(a);
int b = 2;
网上也有人写的 demo 验证可能会发生指令重排的小程序
public class T04_Disorder {
private static int x = 0, y = 0;
private static int a = 0, b =0;
public static void main(String[] args) throws InterruptedException {
int i = 0;
for(;;) {
i++;
x = 0; y = 0;
a = 0; b = 0;
Thread one = new Thread(new Runnable() {
public void run() {
//由于线程one先启动,下面这句话让它等一等线程two. 读着可根据自己电脑的实际性能适当调整等待时间.
//shortWait(100000);
a = 1;
x = b;
}
});
Thread other = new Thread(new Runnable() {
public void run() {
b = 1;
y = a;
}
});
one.start();other.start();
one.join();other.join();
String result = "第" + i + "次 (" + x + "," + y + ")";
if(x == 0 && y == 0) {
System.err.println(result);
break;
} else {
//System.out.println(result);
}
}
}
public static void shortWait(long interval){
long start = System.nanoTime();
long end;
do{
end = System.nanoTime();
}while(start + interval >= end);
}
}
假设指令重排不会发生,那么 result
将不会打印,实际情况是:循环 n 次之后会打印 result
。
volatile
可以禁止指令重排。
![773973f2b1d1fd632cba77d2b9c99ee5.png](https://i-blog.csdnimg.cn/blog_migrate/f571c02064c83a2d971b25ff3ad175c5.png)
大致简单理解,加了内存屏障之后,代码分成 1,2,3部分。1 部分代码你怎么指令重排我不管,但是 1 部分代码执行完了之后,必须执行 2 部分代码,再执行 3 部分代码。
内存屏障
为了禁止 编译器重排序
和 CPU 重排序
,在编译器和 CPU 层面都有对应的指令,也就是内存屏障(Memory Barrier)。编译器的内存屏障,只是为了告诉编译器不要对指令进行重排序。当编译完成之后,这种内存屏障就消失了。
CPU 并不会感知到编译器中内存屏障的存在。而CPU的内存屏障是CPU提供的指令,可以由开发者显示调用。
CPU内存屏障分成四种:
(1)LoadLoad
:禁止读和读的重排序。
读1 ; LoadLoad ; 读 2。LoadLoad 屏障确保读 1 和 读 2 排序。
(2)StoreStore
:禁止写和写的重排序。
写 1; StoreStore; 写 2。StoreStore 屏障确保 写1
立刻刷新数据到主存,并保证别的线程中的数据失效的操作,不能和 写 2
进行重排序。
(3)LoadStore
:禁止读和写的重排序。
读 1;LoadStore; 写 2。确保 读 1
操作先于 写 2
及其后所有的存储指令刷新数据到内存的操作。
(4)StoreLoad
:禁止写和读的重排序。
写 1;StoreLoad;读 2。该屏障确保 写 1
立刻刷新数据到内存的操作先于 读 2 及其后续别的读。
这里只探讨为了实现 volatile 关键字的语义的一种参考做法:(1)在 volatile 写操作的前面插入一个 StoreStore
屏障。保证 volatile 写操作不会和之前的写操作重排序。
(2)在 volatile 写操作的后面插入一个 StoreLoad
屏障。保证 volatile 写操作不会和之后的读操作重排序。
(3)在 volatile 读操作的前面插入一个 LoadLoad
屏障。保证 volatile 读操作不会和之前的读操作重排序。
(4)在 volatile 读操作的后面插入一个 LoadStore
屏障。保证volatile读操作不会和之后的写操作重排序。
volatile 写
public class VolatileDemo2 {
private static volatile int a = 1;
public static void main(String[] args) {
int b = 2;
// StoreStore
a = 2; // volatile 写
// StoreLoad
int c = b;
}
}
b=2 赋值这个 store1 (写1) 不能和 a=2 这个赋值 store2 (写 2) 操作重排序。
a =2 赋值这个 store2 (写 1) 不能和 c=b 这个 load1 (读 2) 重排序。
volatile 读
public class VolatileDemo2 {
private static volatile int a = 1;
public static void main(String[] args) {
int b = 1;
int c = b;
// LoadLoad
int d = a; // volatile 读
// LoadStore
int e = 2;
}
}
c=b 这个 load1(读 1) 不能和 d=a load2(读 2)重排序。
d=a load1(读 1)不能和 e=2 (写 2 ) 重排序。
总结
volatile 的可见性是通过内存屏障实现的。volatile 修饰的变量只要修改了,别的线程读取到的就是最新的值。
JDK 1.8 开始也提供了 api 层面的内存屏障,供我们使用。
public final class Unsafe {
// load 是读 ,store 是写
/**
* 禁止 load 操作重排序。屏障前的load操作不能被重排序到屏障后,屏障后的load操作不能被重排序到屏障前
* loadFence=LoadLoad+LoadStore
* @since 1.8
*/
public native void loadFence();
/**
* 禁止store操作重排序。屏障前的store操作不能被重排序到屏障后,屏障后的store操作不能被重排序到屏障前
* storeFence=StoreStore+LoadStore
* @since 1.8
*/
public native void storeFence();
/**
* 禁止load、store操作重排序
* fullFence=loadFence+storeFence+StoreLoad
* @since 1.8
*/
public native void fullFence();
}
public class VolatileDemo {
private static int a = 0;
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
while (a == 0) {
// 仅仅加了内存屏障,程序可以退出
getUnSafe().loadFence();
}
System.out.println("退出程序");
}, "线程 1").start();
System.out.println("修改 a=1 之前");
Thread.sleep(3000);
a = 1;
System.out.println("修改 a=1 之后");
}
public final static Unsafe getUnSafe() {
try {
// 获取 Unsafe 内部的私有的实例化单例对象
Field field = Unsafe.class.getDeclaredField("theUnsafe");
// 无视权限
field.setAccessible(true);
return (Unsafe) field.get(null);
} catch (Exception e) {
throw new RuntimeException("获取 unfafe 失败");
}
}
}
上述 demo 实际只增加了 getUnSafe().loadFence();
使用,就改变了运行效果。
volatile 并不能保证原子性
public class VolatileDemo3 {
private static volatile int a = 0;
private static final int count = 10;
public static void main(String[] args) throws InterruptedException {
final CountDownLatch count2 = new CountDownLatch(count);
for (int i = 0; i new Thread(() -> {
try {
Thread.sleep(500);
a ++;
count2.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
count2.await();
System.out.println(a);
}
}
最终打印的结果可能不是 10 。a++
不是一个原子操作。a++ 可以理解为
int b=a;
a=b+1;
volatile 并不能保证原子性
单例模式
饿汉式
public class SingletonDemo {
private static final SingletonDemo INSTANCE = new SingletonDemo();
private SingletonDemo() {
}
public static SingletonDemo getInstance() {
return SingletonDemo.INSTANCE;
}
}
一般项目中我们用这种用法即可,简单方便,也没谁闲着无聊利用反射给你打破单例。
懒汉式
饿汉式不管你用不用这个单例,只要类加载,单例就给你初始化好了。
有的人细节控,强迫症想节约那可怜的内存,当用到这个单例的时候单例再实例化。
public class SingletonDemo1 {
private SingletonDemo1() {
}
public static SingletonDemo1 getInstance() {
System.out.println("SingletonDemo1Holder 类加载");
return SingletonDemo1Holder.getInstance();
}
private static class SingletonDemo1Holder {
private static final SingletonDemo1 INSTANCE = new SingletonDemo1();
public static SingletonDemo1 getInstance() {
return SingletonDemo1Holder.INSTANCE;
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println(SingletonDemo1.getInstance());
System.out.println(SingletonDemo1.getInstance());
}
}
运行的时候加上这个 -XX:+TraceClassLoading
会打印加载的类。
![2e2f15fa9c283cea94dd58a999aa0092.png](https://i-blog.csdnimg.cn/blog_migrate/86eeb2ccad9b529cde9d9eb743fbc1a1.png)
从图中我们可以看到调用 SingletonDemo1.getInstance()
的时候,才加载的 SingletonDemo1Holder
类,再实例化单例,达到懒加载的要求。
DCL 实现单例
以上单例的实现看着没啥技术含量,下面介绍一下 DCL
(Double-checked locking),双重检查锁的实现,这也是面试会问到的点。
public class SingletonDemo2 {
// 考点在这里,要不要加 volitale ???
private volatile static SingletonDemo2 INSTANCE;
private SingletonDemo2() {
}
public static SingletonDemo2 getInstance() {
if (INSTANCE == null) {
synchronized (SingletonDemo2.class) {
if (INSTANCE == null) {
// 对象实例化
INSTANCE = new SingletonDemo2();
}
}
}
return INSTANCE;
}
}
对象实例化实际可以简单理解为以下几个步骤:
1、分配对象空间
2、初始化对象
3、将对象指向分配的内存空间
当指令重排的时候,2 和 3 会进行重排序,导致有的线程可能拿到未初始化的对象调用,存在风险问题。
伪共享
volatile
给我们带来了变量 可见性
的功能,但是当使用不当,会掉入另一个 伪共享
的坑。先看 demo.
public class VolatileDemo3 {
private static volatile Demo[] demos = new Demo[2];
// @sun.misc.Contended
private static final class Demo {
private volatile long x = 0L;
}
static {
demos[0] = new Demo();
demos[1] = new Demo();
}
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(() -> {
for (long i = 0; i 10000_0000L; i++) {
demos[0].x = i;
}
});
Thread thread = new Thread(() -> {
for (long i = 0; i 10000_0000L; i++) {
demos[1].x = i;
}
});
long start = System.nanoTime();
thread.start();
thread1.start();
thread.join();
thread1.join();
long end = System.nanoTime();
long runSecond = (end - start) / 100_0000;
System.out.println("运行毫秒:" + runSecond);
}
}
上述代码,存在伪共享的情况,我电脑运行 运行毫秒:2764
// 运行的时候,需要加上参数 -XX:-RestrictContended
public class VolatileDemo3 {
private static volatile Demo[] demos = new Demo[2];
@sun.misc.Contended
private static final class Demo {
private volatile long x = 0L;
}
static {
demos[0] = new Demo();
demos[1] = new Demo();
}
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(() -> {
for (long i = 0; i 10000_0000L; i++) {
demos[0].x = i;
}
});
Thread thread = new Thread(() -> {
for (long i = 0; i 10000_0000L; i++) {
demos[1].x = i;
}
});
long start = System.nanoTime();
thread.start();
thread1.start();
thread.join();
thread1.join();
long end = System.nanoTime();
long runSecond = (end - start) / 100_0000;
System.out.println("运行毫秒:" + runSecond);
}
}
上述代码,使用 @sun.misc.Contended
避免伪共享,我电脑运行 运行毫秒:813
相似的用法在 ConcurrentHashMap
可以看到,
@sun.misc.Contended
static final class CounterCell {
volatile long value;
CounterCell(long x) { value = x; }
}
上述代码展示了伪共享会降低代码的运行速度。什么是伪共享呢。
还记得 Cpu 中的 L1
L2
L3
吗,主存中的数据加载到 Cpu 的高速缓存的最小单位就是 缓存行
(64 bit)。Cpu 的缓存失效,也是以缓存行为单位失效。
当 Cpu
从内存加载数据的时候,它会把可能会用到的数据和目标数据一起加载到 L1/L2/L3
中。上述代码的变量 private static volatile Demo[] demos = new Demo[2];
这两个变量被一起加载到同一个缓存行中去了,一个线程修改了其中的 demos[0].x
导致缓存行失效,另一个线程修改 demos[1].x = i;
的时候发现缓存行失效,会去主存重新加载新的数据,两个线程相互影响导致不停从内存加载,运行速度自然降低了。
@sun.misc.Contended
作用就是让 demos[0]
和 demos[1]
分配在不同的缓存行中去。
我们也可以通过对齐填充,而避免伪共享。
缓存行
通常都是 64 bit。而 long 为 8 个 bit,我们自己补充 7 个没有用 long 变量就可以让 x 和 7个没用的变量单独一个缓存行
public class VolatileDemo3 {
private static volatile Demo[] demos = new Demo[2];
private static final class Demo {
private volatile long x = 0L;
// 缓存行对齐填充的无用数据
private volatile long pading1, pading2, pading3, pading4, pading5, pading6, pading7;
}
static {
demos[0] = new Demo();
demos[1] = new Demo();
}
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(() -> {
for (long i = 0; i 10000_0000L; i++) {
demos[0].x = i;
}
});
Thread thread = new Thread(() -> {
for (long i = 0; i 10000_0000L; i++) {
demos[1].x = i;
}
});
long start = System.nanoTime();
thread.start();
thread1.start();
thread.join();
thread1.join();
long end = System.nanoTime();
long runSecond = (end - start) / 100_0000;
System.out.println("运行毫秒:" + runSecond);
}
}
欢迎关注我的微信公众号【Mflyyou】获取持续更新。
github.com/zhangpanqin/MFlyYou 收集技术文章及我的系列文章,欢迎 Star。