文章目录
💡volatile保证内存可见性
Volatile 修饰的变量能够保证"内存可见性"以及防止"指令重排序"
什么是可见性:当某个线程修改了某个共享变量,其他的线程是否可以看见修改后的内容;
因为访问一个变量时,CPU就会先把变量从内存中读出来,然后放到CPU寄存器中进行运算;运算完之后,再将新的数据在内存中进行刷新;
对于操作系统来讲,读内存的速度是比较慢的,(注意:这里的慢 是 相对于寄存器而言的,就像,读内存要比读硬盘快上千倍或上万倍,读寄存器比读内存快上千倍上万倍), 这时候就会影响执行的效率。为了提高效率,编译器就会对代码进行一个优化,把读内存的操作优化成读寄存器,从而减少对内存的读取,提高整个效率;
举个例子:
代码目的:创建两个线程,通过线程2修改线程1的循环判断条件来终止线程1的循环执行
java
public class Demo1 {
private static int flag = 0;
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
while(flag == 0) {
//当循环不等于0时,一直循环,直到flag被改变
}
System.out.println("thread1 执行结束");
});
Thread thread2 = new Thread(() -> {
Scanner in = new Scanner(System.in);
System.out.println("更改flag:");
//通过更改flag终止线程1的执行
flag = in.nextInt();
System.out.println("输入成功");
});
thread1.start();
thread2.start();
}
}
根据结果可以看到,线程1并没有终止循环,这就是"内存可见性"所导致的线程不安全👇
在多线程的环境下(在单线程环境下没问题),如果编译器作出优化,可能就会导致bug,虽然提高了效率,但是最后结果却是错误的,
此时就需要程序员使用Volatile关键字告诉编译器,不需要进行代码优化:
直接给flag加上Volatile即可
注意, volatile只能够保证内存可见性问题,不会保证代码的原子性,但是Synchronized既可以保证内存可见性,也能保证原子性;
以上就是volatile能够保证内存可见性的讲解
💡单例模式
单例模式是一种经典的设计模式了,它的作用就是保证在有些场景下,需要一个类只能有一个对象,而不能有多个对象,比如像你以后娶媳妇,你娶媳妇肯定是只能娶一个,而不能娶两个;
但是,问题来了,一个类只需要一个对象,那在new对象的时候只new一次对象不就可以了么,为什么还要弄个这么麻烦的东西呢?
因为啊,只new一次对象确实是只有一个,但是呢,如果你在写代码的过程中忘了呢,然后又new了一次,这种概率是很大的,毕竟,人是最不靠谱的动物😅,就像是有一句话说的好:宁可相信世界上有鬼,也不要相信男人的那张嘴😂,所以的,为了防止这种失误发生,就有了单例模式,在Java中也有许多类似的机制,比如final,就会保证修饰的变量肯定是不能改变的;@override,保证你这方法肯定是一个重写方法;这些都是在语法方面进行了一些限制,但是,在语法方面,对于单例并没有特定的语法,所以,这里就通过编程技巧来达到类似的限制效果;
单例模式的两种实现方式:
💡饿汉模式
1.在类中实例化类的对象,给外界提供一个方法来使用这个对象;
2.将构造方法用private修饰,保证在类外不能再实例化这个类对象
java
public class SingleTon {
//在类的内部实例化对象
public static SingleTon instance = new SingleTon();
//定义一个方法,用来获取这个对象
//后序如果类外的代码想要使用对象时,直接调用这个方法即可
public static SingleTon getInstance() {
return instance;
}
//设置一个私有的构造方法,保证在这个类外无法实例化这个对象
private SingleTon(){
}
}
可以看到,这里的对象被static修饰,所以在类被加载的时候创建,创建的时机就比较早,并且被static修饰的对象只会被创建一次,所以这种在类加载时就创建实例的模式称为饿汉模式
💡懒汉模式
懒汉模式单线程版:
这样的写法与上面的相同点就是:同样在类外不能再第二次实例化对象,不同点是:将创建对象的时机放在getInstance方法中,这样在类加载的时候就不会创造实例,而是当第一次调用这个方法时才会去创建;
java
public class SingleTon {
public static SingleTon instance = null;
//定义一个方法,用来获取这个对象
//后序如果类外的代码想要使用对象时,直接调用这个方法即可
public static SingleTon getInstance() {
//懒汉模式
if(instance == null) {
instance = new SingleTon();
}
return instance;
}
//设置一个私有的构造方法,保证在这个类外无法实例化这个对象
private SingleTon(){
}
}
💡懒汉模式多线程版
在线程安全方面,上面的饿汉模式是在多线程下是安全的,而懒汉模式在多线程下是不安全的;
因为,如果多个线程同时访问一个变量 ,那么不会出现不安全问题,如果多个线程同时修改一个变量,就有可能出现不安全问题;
饿汉模式下,只进行了访问,没有涉及到修改
懒汉模式下,不仅进行了访问,还涉及了修改,那么下面就讲解以下懒汉模式在多线程下如何会产生不安全
既然出现了不安全问题,那么如何将懒汉模式修改成安全的呢?
💡方法:进行加锁,使线程安全
但是,如果锁加在这个地方,仍然是不安全的,因为,这样还是会进行穿插执行,如果两个并发的进入的 if 语句中,那么,就会进行锁竞争,假设,thread1 获取到了锁,thread2 在阻塞等待,等到 thread1 创建一次对象,释放锁后,thread2 就又会载获取到锁,进行创建对象,所以,这个加锁操作并没有保证它是一个整体(非原子性)
所以说,并不是加了锁就安全,只有锁加对了才会安全,在加锁的时候要保证以下几方面:
-
锁的 {} 的范围是合理的,能够把需要作为整体的每个部分都包括进去;
-
锁的对象能够起到锁竞争的效果;
懒汉模式多线程版改进👇:
将if语句和new都放在锁里面成为一个整体,这样就避免了会穿插执行;
java
public static SingleTon getInstance() {
synchronized (SingleTon.class) {
if(instance == null) {
instance = new SingleTon();
}
}
return instance;
}
但是上述代码还有一个问题,每当调用getInstance时,都会尝试去进行加锁,而加锁是一个开销很大的操作,而懒汉模式之所以会出现线程不安全问题,是因为只是在第一次调用getInstance方法new对象时,可能会出现问题,但是,只要new完对象以后,就不用再进行锁竞争了,直接访问就可以了,所以再次进行优化👇:
java
public static SingleTon getInstance() {
//在最外面在进行一次判断
if(instance == null) {
synchronized (SingleTon.class) {
if(instance == null) {
instance = new SingleTon();
}
}
}
return instance;
}
在第一次实例化对象后,以后再调用个getInstance方法时,就不会再创建对象,而且也不会再去获取锁,因为,第一个if判断语句都不会进去,所以不会执行到加锁的语句;
上面的单例模式看着好像是完全没问题了,但是,还是有一个问题,就是可能会触发指令重排序问题,所以就需要使用volatile解决指令重排序问题:
💡volatile防止指令重排序
指令重排序:编译器会保证在你代码逻辑不变的情况下,对代码进行优化,使代码的性能得到提高,这样的操作称为指令重排序;
举个例子:
在代码中,在实例化对象这一步可能会出现指令重排序问题,下面就来讲解一下为什么👇
对于上述的指令重排序问题,解决方案就是:使用volatile关键字修饰singleTon
**线程安全的单例模式(懒汉模式)**👇
java
public class SingleTon {
//使用volatile关键字修饰,防止指令重排序
public static volatile SingleTon singleTon = null;
public static SingleTon getSingleTon() {
if(singleTon == null) {
synchronized (SingleTon.class) {
if(singleTon == null) {
singleTon = new SingleTon();
}
}
}
return singleTon;
}
private SingleTon() {
};
}
💡💡这里再次提醒,使用单例模式要注意三个要点:
- 加锁
- 两层if判断
- 使用volatile修饰引用,防止指令重排序