java设计模式-单例模式(四)

我不是女神ヾ 2024-04-18 20:08 62阅读 0赞

> 单例顾名思义只能有单一的实例，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为

使用场景：如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取；还有如数据库连接池也是采用单例模式，只有一个连接池就可以了，再多就是浪费系统资源；还有如spring中的bean默认是单例;线程池;

单例的优点:  
1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例  
2.提供了对唯一实例的受控访问  
3.由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能  
4.避免对共享资源的多重占用  
单例的缺点:  
1.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难  
2.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。  
实现单利模式的原则：  
a.私有构造方法  
b.私有静态引用指向自己实例  
c.以自己实例为返回值的公有静态方法

饿汉式：单例实例在类装载时就构建，急切初始化

public class SingleOne {
        /**私有化构造方法*/
        private SingleOne(){}
        /**类加载就实例化,私有静态引用指向自己实例 */
        private static SingleOne instance = new SingleOne();
        /**以自己实例为返回值的公有静态方法*/
        public static SingleOne getInstance(){
            return instance;
        }
    }

验证是否是单例:发现内存地址值是一样，说明多次获取是一个实例对象。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA1MDkwNTI_size_16_color_FFFFFF_t_70]  
优点  
1.线程安全  
2.在类加载的同时已经创建好一个静态对象，调用时反应速度快  
缺点 ： 资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化 。

--------------------

懒汉式：单例实例在第一次被使用时构建，延迟初始化。

public class SingleTwo {
        /**私有化构造方法*/
        private SingleTwo(){}
        /**
         *私有静态引用指向自己实例
         *volatile 禁止指令重排(多线程安全)
         */
        private static volatile SingleTwo instance = null;
        /**以自己实例为返回值的公有静态方法*/
        public static SingleTwo getInstance(){
            //多个线程判断instance都为null时，在执行new操作时多线程会出现重复情况
            /*if(instance == null){
                instance = new SingleTwo();
            }*/
    
            //==============================
            //双重检查,防止多线程时创建多个实例
            if(instance == null){
                synchronized (SingleTwo.class){
                    if(instance == null){
                        instance = new SingleTwo();
                    }
                }
            }
            return instance;
        }
    }

优点:资源利用率高，不执行getInstance()不被实例,  
缺点:一次加载时反应不够快

#### 这种单例可以被反序列化破坏 ####

public class SingleFive { 
        public static void main(String[] args) { 
            // 通过反序列化获取单例模式对象
            String path = "single";
            //通过SingleTwo 方式获取单例对象
            SingleTwo single1 = SingleTwo.getInstance();
            try{ 
                //序列化到文件
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(path));
                objectOutputStream.writeObject(single1);
                ObjectInputStream result = new ObjectInputStream(new FileInputStream(path));
                SingleTwo resultSingleton = (SingleTwo) result.readObject();
                // 反序列化出来的对象，和原对象，不是同一个对象。
                result.close();
                System.out.println(single1);
                System.out.println(resultSingleton);
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }
    }

只要单例类，加如下方法：

/** * 反序列化 就会自动调用这个 readResolve方法来返回我们指定好的对象了, 单例规则也就得到了保证. * */
    private Object readResolve() throws ObjectStreamException { 
       return instance;
    }

#### 还可以被反射破坏单例 ####

使用静态内部类的方式可以防止被反射破坏单例(如果想要通过反射获取其静态内部类 SingletonStaticClass 并给其属性 singleton 赋值为 null 时,就会抛出异常 IllegalAccessException ,阻止将其值设置为 null)再优化如下:

public class Singleton implements Serializable { 
        private static class SingletonStaticClass { 
            private static final Singleton singleton = new Singleton();
        }
        private Singleton() { 
            synchronized (Singleton.class) { 
                if (SingletonStaticClass.singleton != null) { 
                    throw new RuntimeException("不能重复创建对象");
                }
            }
        } 
        public static Singleton getInstance() { 
            return SingletonStaticClass.singleton;
        }
    }

最建议的一种方法是使用 枚举 来实现单例,这种方式天然的防止通过反射来破坏单例

##### 懒汉式的另一种实现方法： #####

public class SingleThree {
        /**私有化构造方法*/
        private SingleThree(){}
        
        /**内部类*/
        private static class SingleThreeHelp{
            static SingleThree instance = new SingleThree();
        }
        /**以自己实例为返回值的公有静态方法*/
        public static SingleThree getInstance(){
            return SingleThreeHelp.instance;
        }
    }

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化instance，故而不占内存。即当SingleThree 第一次被加载时，并不需要去加载SingleThreeHelp，只有当getInstance()方法第一次被调用时，才会去初始化instance,第一次调用getInstance()方法会导致虚拟机加载SingleThreeHelp类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

所以要根据自己的实际场景来确定使用懒汉式还是饿汉式  
总结： 一般采用饿汉式，若对资源十分在意可以采用静态内部类，不建议采用懒汉式及双重检测  
参考 https://blog.csdn.net/mnb65482/article/details/80458571

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA1MDkwNTI_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ad89568742cf432884e22548f8ddc19a.png