【设计模式】3.单例模式

痛定思痛。 2024-03-26 15:11 82阅读 0赞

## 单例模式 ##

没有懒加载：1.1，1.2  
线程不安全：1.3，1.5（不可以用）  
多线程安全，效率低：1.4  
多线程安全，懒加载，效率可以：1.6，1.7，1.8（推荐）

单例设计模式有八种方式

**1)** 饿汉式\_**(**\_静态常量)

**2)** 饿汉式（静态代码块）

**3)** 懒汉式(线程不安全)

**4)** 懒汉式(线程安全，同步方法)

**5)** 懒汉式(线程安全，同步代码块)

**6)** 双重检查

**7)** 静态内部类

**8)** 枚举

#### 1.1、饿汉式（静态常量） ####

饿汉式（静态常量）应用实例

步骤如下：

1.  构造器私有化 (防止 new )
2.  类的内部创建对象
3.  向外暴露一个静态的公共方法。getInstance
4.  代码实现

public class SingletonTest1 {
        
        public static void main(String[] args) {
        
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
    
            System.out.println(instance1 == instance2);
            System.out.println("instance1.hashCode = " + instance1.hashCode());
            System.out.println("instance2.hashCode = " + instance2.hashCode());
        }
    }
    
    
    class Singleton{
        
        private Singleton() {
        
    
        }
    
        private final static Singleton instance = new Singleton();
    
        public static Singleton getInstance(){
        
            return instance;
        }
    }

优缺点说明：

1.  优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
2.  缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
3.  这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法， 但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果
4.  结论：这种单例模式可用，可能造成内存浪费

例如 java.lang.Runtime  
![Pasted image 20220917203516.png][]

#### 1.2、饿汉式（静态代码块） ####

class Singleton{
        
        private Singleton(){
        
    
        }
    
        private static Singleton instance;
    
        static {
        
            instance = new Singleton();
        }
    
        public static Singleton getInstance(){
        
            return instance;
        }
    }

优缺点说明：

1.  这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
2.  结论：这种单例模式可用，但是可能造成内存浪费

#### 1.3、懒汉式(线程不安全) ####

class Singleton{
        
        private Singleton(){
        
    
        }
    
        private static Singleton instance;
    
        public static Singleton getInstance(){
        
            if (instance == null){
        
                instance = new Singleton();
            }
            return instance;
        }
    
    }

优缺点说明：

1.  起到了 **Lazy Loading** 的效果，但是只能在单线程下使用。
2.  如果在多线程下，一个线程进入了 \*\*if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
3.  结论：在实际开发中，不要使用这种方式.

#### 1.4、懒汉式(线程安全，同步方法) ####

class Singleton{
        
        private Singleton(){
        
    
        }
    
        private static Singleton instance;
    
        public static synchronized Singleton getInstance(){
        
            if (instance == null){
        
                instance = new Singleton();
            }
            return instance;
        }
    }

优缺点说明：

1.  解决了线程安全问题
2.  效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低
3.  结论：在实际开发中，不推荐使用这种方式

#### 1.5、懒汉式(线程不安全，同步代码块) ####

class Singleton{
        
        private Singleton(){
        
    
        }
    
        private static Singleton instance;
    
        public static Singleton getInstance(){
        
            if (instance == null){
        
                synchronized (Singleton.class){
        
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }

这种方式不能解决线程问题  
不推荐使用

#### 1.6、双重检查 ####

class Singleton{
        
        private static  Singleton instance;
    
        private Singleton(){
        
    
        }
    
        public static Singleton getInstance(){
        
            if (instance == null){
        
                synchronized (Singleton.class){
        
                    if (instance == null){
        
                        instance = new Singleton();
                    }
                }
            }
    
            return instance;
        }
    }

上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

要解决双重检查锁模式带来空指针异常的问题，只需要使用 `volatile` 关键字, `volatile` 关键字可以保证可见性和有序性。

class Singleton{
        
    //volatile是Java虚拟机提供的轻量级的同步机制,保证可见性,禁止指令重排(听不懂/(ㄒoㄒ)/~~ )
        private static volatile Singleton instance;
    
        private Singleton(){
        
    
        }
    
        public static Singleton getInstance(){
        
            if (instance == null){
        
                synchronized (Singleton.class){
        
                    if (instance == null){
        
                        instance = new Singleton();
                    }
                }
            }
    
            return instance;
        }
    }

优缺点说明：

1.  Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
2.  这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步.
3.  线程安全；延迟加载；效率较高
4.  结论:在实际开发中，推荐使用这种单例设计模式

#### 1.7、静态内部类 ####

class Singleton{
        
        private Singleton(){
        
    
        }
    
        private static class SingletonInstance{
        
            private static final Singleton INSTANCE = new Singleton();
        }
    
        public static Singleton getInstance(){
        
            return SingletonInstance.INSTANCE;
        }
    }

优缺点说明：

1.  这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
2.  静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
3.  类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
4.  优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
5.  结论：推荐使用.

#### 1.8、枚举 ####

public class SingletonTest08 {
          
        
      
        public static void main(String[] args) {
          
            Singleton instance = Singleton.INSTANCE;  
            Singleton instance2 = Singleton.INSTANCE;  
            System.out.println(instance == instance2);  
            System.out.println(instance.hashCode());  
            System.out.println(instance2.hashCode());  
             
        }  
    }
    enum Singleton{
        
        INSTANCE;
    }

优缺点说明：

1.  这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
2.  这种方式是 **Effective** ***Java*** 作者 ***Josh*** ***Bloch*** 提倡的方式
3.  结论：推荐使用

## 单例模式注意事项和细节说明 ##

1.  单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
2.  当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
3.  单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、***session*** 工厂等)

## 存在的问题 ##

### 问题演示 ###

破坏单例模式：

使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。

#### 序列化反序列化 ####

public class Singleton implements Serializable {
          
          
            //私有构造方法  
            private Singleton() {
        }  
          
            private static class SingletonHolder {
          
                private static final Singleton INSTANCE = new Singleton();  
            }  
          
            //对外提供静态方法获取该对象  
            public static Singleton getInstance() {
          
                return SingletonHolder.INSTANCE;  
            }  
        }

public class Test {
          
            public static void main(String[] args) throws Exception {
          
                //往文件中写对象  
                //writeObject2File();  
                //从文件中读取对象  
                Singleton s1 = readObjectFromFile();  
                Singleton s2 = readObjectFromFile();  
          
                //判断两个反序列化后的对象是否是同一个对象  
                System.out.println(s1 == s2);  
            }  
          
            private static Singleton readObjectFromFile() throws Exception {
          
                //创建对象输入流对象  
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt"));  
                //第一个读取Singleton对象  
                Singleton instance = (Singleton) ois.readObject();  
          
                return instance;  
            }  
          
            public static void writeObject2File() throws Exception {
          
                //获取Singleton类的对象  
                Singleton instance = Singleton.getInstance();  
                //创建对象输出流  
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt"));  
                //将instance对象写出到文件中  
                oos.writeObject(instance);  
            }  
        }

> 上面代码运行结果是`false`，表明序列化和反序列化已经破坏了单例设计模式。

#### 反射 ####

Singleton类：

public class Singleton {
          
          
            //私有构造方法  
            private Singleton() {
        }  
              
            private static volatile Singleton instance;  
          
            //对外提供静态方法获取该对象  
            public static Singleton getInstance() {
          
          
                if(instance != null) {
          
                    return instance;  
                }  
          
                synchronized (Singleton.class) {
          
                    if(instance != null) {
          
                        return instance;  
                    }  
                    instance = new Singleton();  
                    return instance;  
                }  
            }  
        }
        
    
        
        public class Test {
          
            public static void main(String[] args) throws Exception {
          
                //获取Singleton类的字节码对象  
                Class clazz = Singleton.class;  
                //获取Singleton类的私有无参构造方法对象  
                Constructor constructor = clazz.getDeclaredConstructor();  
                //取消访问检查  
                constructor.setAccessible(true);  
          
                //创建Singleton类的对象s1  
                Singleton s1 = (Singleton) constructor.newInstance();  
                //创建Singleton类的对象s2  
                Singleton s2 = (Singleton) constructor.newInstance();  
          
                //判断通过反射创建的两个Singleton对象是否是同一个对象  
                System.out.println(s1 == s2);  
            }  
        }

> 上面代码运行结果是`false`，表明反射已经破坏了单例设计模式

> 注意：枚举方式不会出现这两个问题。

### 问题的解决 ###

*  序列化、反序列方式破坏单例模式的解决方法
    
    在Singleton类中添加`readResolve()`方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。
    
    **Singleton类：**
    
        public class Singleton implements Serializable {
                
          
            //私有构造方法  
            private Singleton() {
              }  
          
            private static class SingletonHolder {
                
                private static final Singleton INSTANCE = new Singleton();  
            }  
          
            //对外提供静态方法获取该对象  
            public static Singleton getInstance() {
                
                return SingletonHolder.INSTANCE;  
            }  
              
            /**  
             * 下面是为了解决序列化反序列化破解单例模式  
             */  
            private Object readResolve() {
                
                return SingletonHolder.INSTANCE;  
            }  
        }
    
    **源码解析：**
    
    ObjectInputStream类

public final Object readObject() throws IOException, ClassNotFoundException{
          
            ...  
            // if nested read, passHandle contains handle of enclosing object  
            int outerHandle = passHandle;  
            try {
          
                Object obj = readObject0(false);//重点查看readObject0方法  
            .....  
        }  
              
        private Object readObject0(boolean unshared) throws IOException {
          
            ...  
            try {
          
                switch (tc) {
          
                    ...  
                    case TC_OBJECT:  
                        return checkResolve(readOrdinaryObject(unshared));//重点查看readOrdinaryObject方法  
                    ...  
                }  
            } finally {
          
                depth--;  
                bin.setBlockDataMode(oldMode);  
            }      
        }  
              
        private Object readOrdinaryObject(boolean unshared) throws IOException {
          
            ...  
            //isInstantiable 返回true，执行 desc.newInstance()，通过反射创建新的单例类，  
            obj = desc.isInstantiable() ? desc.newInstance() : null;   
            ...  
            // 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为true  
            if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
          
                // 通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量  
                // 这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。  
                Object rep = desc.invokeReadResolve(obj);  
                ...  
            }  
            return obj;  
        }

*  反射方式破解单例的解决方法
    
        public class Singleton {
                
          
            //私有构造方法  
            private Singleton() {
                
                /*  
                   反射破解单例模式需要添加的代码  
                */  
                if(instance != null) {
                
                    throw new RuntimeException();  
                }  
            }  
              
            private static volatile Singleton instance;  
          
            //对外提供静态方法获取该对象  
            public static Singleton getInstance() {
                
          
                if(instance != null) {
                
                    return instance;  
                }  
          
                synchronized (Singleton.class) {
                
                    if(instance != null) {
                
                        return instance;  
                    }  
                    instance = new Singleton();  
                    return instance;  
                }  
            }  
        }

![image.png](http://obs-knowledge.oss-cn-beijing.aliyuncs.com/img/20230227103011.png)
    
      
      
      说明:
      
      这种方式比较好理解。当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。

[Pasted image 20220917203516.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f9e5120b905e47feaa8e28e579ec6758.png