⭐️引言⭐️
我将单例模式分为两部分
单例模式(上):
- 为什么需要单例模式+案例讲解
- 实现单例模式
- 破坏单例模式的情况及其解决方法
- 反射
- 序列化
单例模式(下)
- 容器单例
- ThreadLocal线程单例
- 使用单例处理资源访问冲突
- 使用单例表示全局唯一类
⭐️为什么需要单例模式⭐️
防止重复创建对象而损耗性能
在此情况下使用单例模式,好处有这些:
1.在内存中只有一个对象,节省内存空间。
2避免频繁的建立销毁对象,能够提升性能。
3.避免对共享资源的多重占用。
4.能够全局访问。
比如说我们想使用一个工具类,在普通情况下,工具类中方法使用静态方法即可,若在特殊情况下,比如多数据源,我们可以使用单例模式来开发这个工具类。
此时,假如有很多类需要这个工具类,如果是普通的类,那么需要频繁的创建对象,使用方法,销毁对象,会占用内存资源。
实际例子:
你是一个天天写检讨书的同学,你如何省时省力的去写检讨,那就是建立一份万能模板,每次写检讨,就直接拿到这份万能检讨即可。在这个过程中:一份万能模板即可,不需要新的,每次使用这个模板即可,使用的结果就是省时省力。
大部分情况下,在没有业务需求的情况下,若使用单例模式,我们的目的一般是用来节省内存(下一个文章介绍其他好处),下面我们先来说如何实现单例模式,以及一些可能会破坏单例模式的情况
⭐️单例模式代码编写⭐️
单例模式主要分为两种,饿汉式和懒汉式。
区别:
- 饿汉式:在类被加载的时候,因为使用到了static修饰符,然后又创建了自己的实例,所以该实例会在类加载时直接创建。—占用系统内存
- 懒汉式:在调用获取该对象方法的时候,才创建对象。(我们把这种行为叫做延迟加载)
⭐️懒汉式1.0 版本⭐️
思路:
判断当前
目标:基本实现懒汉式单例模式(有缺陷)
//延迟加载
class LazySingleton{
private static LazySingleton instance;
public LazySingleton getInstance(){
if (instance==null){
instance=new LazySingleton();
}
return instance;
}
}
⭐️懒汉式2.0 版本⭐️
写代码,在追求正确的情况下,还得追求适用性。既然这么说了,V1.0肯定有缺陷,缺陷就在于:不适用多线程环境
解释:
getInstance中有三行语句,假如现在有两个线程,一个正在创建对象,但是没有创建完毕(instance 为 null),另一个对象也进入了该线程,然后因为另一个线程创建对象未完成,导致了instance 为null, 然后又创建了一个对象
流程:
时刻1:线程1正在创建对象,但是未创建完成 —>instance == null
时刻1:线程2正在判断instance是否未null —>instance ==null 成立 —>创建对象
时刻2: 线程1创建好对象
时刻3:线程2创建好对象
问题出在哪里?
根据上面的解释,很容易发现,问题出在if判断语句和创建对象,这几行代码不是一个整体,所以在一个线程运行的时候,另一个线程可能乘虚而入。俗话说的好,苍蝇不叮无缝的蛋,我们把这几行代码变成一个整体。
有一个关键词:synchronized,使用了这个关键词后只能有一个线程能进入该方法,那么整个方法都是一个整体,自然内部是不会有问题的。
class LazySingleton{
private static LazySingleton instance;
// 给整个方法加上锁,但是对性能影响比较大
使用多线程debug
public synchronized LazySingleton getInstance(){
if (instance==null){
instance=new LazySingleton();
}
return instance;
}
}
⭐️懒汉式3.0 版本⭐️
使用synchronized会导致这个方法的性能较差,我们可以考虑把synchronized放到内部
思考:我们可以使用 synchronized (LazySingleton.class)来锁定if语句
大家看看下面的代码好不好
public LazySingleton getInstance(){
synchronized (LazySingleton.class){
if (instance==null){
instance=new LazySingleton();
}
}
return instance;
}
其实是不够好的,因为我们假如把整个if语句锁起来,那么和把锁放在方法上区别并不够大,毕竟整个方法里面也只有一个if和return,我们已经把if全包起来了。
假如实例创建完毕,我们线程1,2再次获取,此时也仅有一个能先判断,另一个等着。
**问题出在哪里?:**出在即使对象存在,线程1,2无法同时进入判断语句。
解决方法: 在最外层再加入一层if
升级版
public LazySingleton getInstance(){
// 先判断是否为null ,如果空,那么就进入,因为if和创建对象被加锁,所以一个时刻只能有一个线程运行if语句
// 如果不为空,那么不需要等锁,直接返回
if (instance==null){
synchronized (LazySingleton.class){
if (instance==null){
instance=new LazySingleton();
}
}
}
return instance;
}
回顾
问题1:if语句和创建实例语句不是一个整体即不是一个原子操作
出现时刻:线程1正在创建而未创建成功,但是线程2已经判断出instance为null,然后准备创建对象
解决1:给方法加上synchronized
优化:给if语句套上synchronized(但是即使对象存在,线程不能同时进入if语句)
优化2:doublecheck双重检查,再套一个if语句
注意点1:
懒汉式的实例不能用final修饰—>不是在类加载的时候就初始化好
⭐️ 饿汉式 ⭐️
该方式创建的单例是在类加载的时候就已经创建了实例。
饿汉式稍微简单点:但是记住,如果该单例没有使用,那么会浪费内存!!!
class HungrySingleton{
private static HungrySingleton instance = new HungrySingleton();
private HungrySingleton(){
// 当强制使用反射来构造的时候,也无法构造出另一个类
if (instance!=null){
throw new RuntimeException("单例不允许多个实例");
}
}
public static HungrySingleton getInstance(){
return instance;
}
}
⭐️ 有哪些情况会破坏单例模式 ⭐️
反射破坏单例
要搞清楚原因就知道反射是如何破坏单例的:
首先我们要了解到反射是如何破坏单例的—>通过获得单例对象的构造器然后暴力构造一个对象(即使构造器为private)
class HungrySingleton implements Serializable {
private static HungrySingleton instance = new HungrySingleton();
private HungrySingleton(){
// 当强制使用反射来构造的时候,也无法构造出另一个类
if (instance!=null){
throw new RuntimeException("单例不允许多个实例");
}
}
public static HungrySingleton getInstance(){
return instance;
}
//为什么要这么写
private Object readResolve(){
return instance;
}
}
public static void testInvoke() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class objectClass = HungrySingleton.class;
Constructor constructor=objectClass.getDeclaredConstructor();
constructor.setAccessible(true);
HungrySingleton instance = HungrySingleton.getInstance();
HungrySingleton newInstance = (HungrySingleton) constructor.newInstance();
System.out.println(instance);
System.out.println(newInstance);
}
如何解决:
在构造器中判断并抛出异常
思考:
为什么我们使用了饿汉式举例,却没有将懒汉式。因为这种方法只对类加载时就创建好的单例模式有用。(静态内部类单例模式也可以这样使用)
验证懒汉式无法使用此种方法来防止反射
public class LazySingleTon {
private static LazySingleTon lazySingleTon = null;
private LazySingleTon(){
if (lazySingleTon!=null){
throw new RuntimeException("单例不允许多个实例");
}
}
public static LazySingleTon getInstance(){
if (lazySingleTon == null){
lazySingleTon = new LazySingleTon();
}
return lazySingleTon;
}
}
test方法
public static void testLazyInvoke() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
// 和之前的有所不同。之前的内部类和饿汉式,都是直接创建出来的
// 但是这里的懒汉式,是在需要的时候才创建出来的,所以我们使用
// 反射获得的结果会有所不同,假如先反射再 getInstance ,那么
// 应该是不同的,假如先 getInstance 再反射,那么无法反射成功
Class objectClass = LazySingleTon.class;
Constructor constructor=objectClass.getDeclaredConstructor();
constructor.setAccessible(true);
LazySingleTon instance = LazySingleTon.getInstance();
LazySingleTon newInstance = (LazySingleTon) constructor.newInstance();
System.out.println(instance);
System.out.println(newInstance);
}
结果:
Exception in thread “main” java.lang.reflect.InvocationTargetException
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
at com.ggzx.design.pattern.singleton.Test.testLazyInvoke(Test.java:89)
at com.ggzx.design.pattern.singleton.Test.main(Test.java:17)
Caused by: java.lang.RuntimeException: 单例不允许多个实例
at com.ggzx.design.pattern.singleton.LazySingleTon.(LazySingleTon.java:8)
… 6 more
但是,这种情况有例外,上面的是先通过getInstance获得单例模式提供的实例,然后再通过反射这种”非法“手段获取对象,此时可以正常报错。但是只要互换代码后,结果就不一样了。
我们先通过”非法“手段获取单例,再通过正常方法获得时,就获得了两个对象.
原因也很明显:因为反射获得对象后, lazySingleTon仍然为null
LazySingleTon newInstance = (LazySingleTon) constructor.newInstance();
LazySingleTon instance = LazySingleTon.getInstance();
序列化
序列化:把对象转换为字节序列的过程称为对象的序列化。
反序列化:把字节序列恢复为对象的过程称为对象的反序列化
public static void testSerializable() throws IOException, ClassNotFoundException {
HungrySingleton instance = HungrySingleton.getInstance();
ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("singleTone"));
objectOutputStream.writeObject(instance);
File file = new File("singleTone");
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
HungrySingleton newInstance = (HungrySingleton) objectInputStream.readObject();
System.out.println(instance);
System.out.println(newInstance);
System.out.println(instance == newInstance);
}
结果:
com.ggzx.design.pattern.singleton.HungrySingleton@14ae5a5
com.ggzx.design.pattern.singleton.HungrySingleton@378bf509
false
可以发现,经过序列化之后,就不被认定为同一个对象了
先说如解决办法
只需要增加一个redResolve方法即可
class HungrySingleton implements Serializable {
private static HungrySingleton instance = new HungrySingleton();
private HungrySingleton(){
// 当强制使用反射来构造的时候,也无法构造出另一个类
if (instance!=null){
throw new RuntimeException("单例不允许多个实例");
}
}
public static HungrySingleton getInstance(){
return instance;
}
//为什么要这么写
private Object readResolve(){
return instance;
}
}
为什么
先查看readObject方法
找到read0方法,这里是读取序列化对象的地方我们的类继承自Object类,找到这里的代码,进入readOrdinaryObject
下面才是关键代码
//obj就是返回的对象
ObjectStreamClass desc = readClassDesc(false);
//如果可以序列化,就通过反射创建对象,通过反射创建的对象是不同的
obj = desc.isInstantiable() ? desc.newInstance() : null;
isInstantiable方法
/** serialization-appropriate constructor, or null if none */
private Constructor<?> cons;
// con是构造器,如果这个对象支持序列化,那么上方的desc.isInstantiable()为真,就通过反射创建一个对象
boolean isInstantiable() {
requireInitialized();
return (cons != null);
}
上面了解了破坏单例模式的原因,下面来找解决方法
来从源代码中找到答案
// 注意其中的hasReadResloveMethod
if (obj != null &&
handles.lookupException(passHandle) == null &&
desc.hasReadResolveMethod())
{
Object rep = desc.invokeReadResolve(obj);
if (unshared && rep.getClass().isArray()) {
rep = cloneArray(rep);
}
if (rep != obj) {
// Filter the replacement object
if (rep != null) {
if (rep.getClass().isArray()) {
filterCheck(rep.getClass(), Array.getLength(rep));
} else {
filterCheck(rep.getClass(), -1);
}
}
handles.setObject(passHandle, obj = rep);
}
}
hasReadResloveMethod方法源代码
/**
* Returns true if represented class is serializable or externalizable and
* defines a conformant readResolve method. Otherwise, returns false.
* 假如有一个readResolve方法,就返回真,
*/
boolean hasReadResolveMethod() {
requireInitialized();
return (readResolveMethod != null);
}
如果存在reaReslove方法,那么就通过反射来调用readReslove方法
private Object readResolve(){
return instance;
}