小饶学编程之JAVA SE第一部分——面向对象：09单例设计模式（Singleton）

青旅半醒 2022-12-20 05:42 119阅读 0赞

### 面向对象：单例设计模式 ###

*  一、单例模式
 *   *  1.1作用
     *  1.2特点
     *  1.3生活实例
     *  1.4常见应用场景
     *  1.5使用原因
     *  1.6优点
     *  1.7关键代码
 *  二、单例模式的五种实现
 *   *  2.1饿汉式
     *  2.2懒汉式
     *  2.3双重检测锁式
     *  2.4静态内部类式
     *  2.5枚举式
     *  2.6测试类Client
     *   *  2.6.1实现代码
         *  2.6.2测试结果
 *  三、总结

# 一、单例模式 #

## 1.1作用 ##

保证一个类只有一个实例,并且提供一个访问该实例的全局访问点（一个可以访问该实例的方法）。

## 1.2特点 ##

*  单例类只能有一个实例。
 *  单例类必须自己创建自己的唯一实例。
 *  单例类必须给所有其他对象提供这一实例。

## 1.3生活实例 ##

太阳系只有一个太阳（月亮），  
一个国家只有一个领导者，  
一个班级只有一个班主任。

## 1.4常见应用场景 ##

1.Windows的任务管理器，系统里面有很多个软件（单例的）。  
2.windows的回收站，在整个系统运行过程中,回收站一直维护着仅有的一个实例。项目中,读取配置文件的类,一般也只有一个对象。没有必要每次使用配置文件数据,每次new-一个对象去读取。  
3.网站的计数器,不用每次刷新都在数据库里加一次，用单例先缓存起来，否则难以同步。  
4.应用程序的日志应用，这一般是由于共享的日志文件一直处于打开状态,因为只能有一个实例去操作,否则内容不好追加。  
5.数据库连接池的设计，因为数据库连接是一种数据库资源。  
6.操作系统的文件系统,一个操作系统只能有一个文件系统。

## 1.5使用原因 ##

**（1）节省资源**

比如：大家都要喝水，但是没必要每人家里都打一口井是吧，通常的做法是整个村里打一个井就够了，大家都从这个井里面打水喝。

**（2）方便控制**

就像日志管理，如果多个人同时来写日志，你一笔我一笔那整个日志文件都乱七八糟，如果想要控制日志的正确性，那么必须要对关键的代码进行上锁，只能一个一个按照顺序来写，而单例模式只有一个人来向日志里写入信息方便控制，避免了这种多人干扰的问题出现。

## 1.6优点 ##

*  由于单例模式只生成一个实例 ，**减少了系统性能开销**,当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象 ,然后永久驻留内存的方式来解决。
 *  单例模式可以在系统设置全局的访问点,**优化环共享资源访问**,例如可以设计一一个单例类,负责所有数据表的映射处理。

## 1.7关键代码 ##

*  构造函数（构造器）是私有的。（别人无法访问，只有自己可以访问）。
 *  提供一个属性（私有的、静态的、指向对象）。instance=new SingletonDemo1
 *  提供一个方法（公共的、静态的、返回对象）。getinstance（）
 *  判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

# 二、单例模式的五种实现 #

*  主要：  
    **饿汉式**：线程安全、调用效率高，但是，不能延时加载  
    **懒汉式**：线程安全、调用效率不高，但是，可以延时加载(使用时才加载)
 *  其他：  
    **双重检测锁式**：线程安全、调用效率高，可以延时加载（由于JVM底层内部模型原因，偶尔会出问题，不建议使用）  
    **静态内部类式**：线程安全、调用效率高，但是，可以延时加载  
    **枚举式**：线程安全、调用效率高、不能延时加载。并且可以天然防止反射和反序列化漏洞

## 2.1饿汉式 ##

下面展示 `饿汉式实现单例模式的代码片`。

public class SingletonDemo1 {
        
        //2.类初始化时，立即加载这个对象（没有延时加载的优势，可能浪费资源）,给instance静态属性。由于加载类时，天然的，线程安全。
        private static SingletonDemo1 instance =new SingletonDemo1();//类的成员属性
        //1.构造方法私有化（构造器私有）
        private  SingletonDemo1(){
        
        }
        //3.方法没有同步，调用效率高！
        public static SingletonDemo1 getInstance(){
        
            return instance;
        }
    }

## 2.2懒汉式 ##

下面展示 `懒汉式实现单例模式的代码片`。

public class SingletonDemo2 {
        
        //2.类初始化时，不初始化这个对象（延时加载，真正使用时才创建）
        private static SingletonDemo2 instance;
        //1.构造方法私有化
        private SingletonDemo2(){
        
    
        }
        //3.方法同步，线程调用这个方法，都会进行等待，调用效率低
        public  static synchronized SingletonDemo2 getInstance(){
        
            if(instance==null){
        //如果没有创建对象就创建；如果有对象就返回对象
                instance=new SingletonDemo2();
            }
            return instance;
        }
        /*
        * synchronized 同步块，避免在多线程，并发量高时，创建多个对象。
        *
        * */
    }

## 2.3双重检测锁式 ##

这个模式将同步内容下放到if内部,提高了执行的效率，不必每次获取对象时都进行同步。只有第一次才同步创建了，以后就没必要了。

**问题:**

由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题，不建议使用。

下面展示 `双重检测锁式实现单例模式的代码片`。

public class SingletonDemo3 {
        
        private static SingletonDemo3 instance = null;
        public static SingletonDemo3 getInstance(){
        
            if (instance==null){
        
                SingletonDemo3 sc;//定义属性
                //同步块的第一次检测
                synchronized (SingletonDemo3.class){
        
                    sc =instance;
                    if (sc==null){
        
                    //同步块的第二次检测
                        synchronized (SingletonDemo3.class) {
        
                            if (sc==null) {
        
                            sc=new SingletonDemo3();
                            }
                        }
                        instance =sc;
                    }
                }
            }
            return instance;
        }
        private SingletonDemo3(){
        
    
        }
    }

## 2.4静态内部类式 ##

静态内部类式也是懒加载方式

**特点：**

*  外部类没有static属性 ,则不会像饿汉式那样立即加载对象。
 *  只有真正调用getinstance0,才会加载静态内部类。加载类时是线程安全的。instance是static final类型，保证了内存中只有这样一个实例存在 ,而且只能被赋值一次,从而保证了线程安全性.
 *  兼备了并发高效调用和延迟加载的优势!

下面展示 `静态内部类式实现单例模式的代码片`。

public class SingletonDemo4 {
        
       //2.在静态内部类里面创建对象
        private static class SingletonClassInstance{
        
            private static final SingletonDemo4 instance =new SingletonDemo4();
        }
            //3.访问方法：方法没有同步，调用效率高！
            public static SingletonDemo4 getInstance(){
        
                return SingletonClassInstance.instance;
            }
             //1.构造方法私有化
            private SingletonDemo4(){
        
    
            }
    }

## 2.5枚举式 ##

**优点:**

*  实现简单
 *  枚举本身就是单例模式。由JVM从根本上提供保障!避免通过反射和反序列化的漏洞

**!缺点:**

*  无延迟加载

下面展示 `枚举式实现单例模式的代码片`。

public enum SingletonDemo5 {
        
      //这个枚举元素，本身就是单例对象
         INSTANCE;
         //添加自己需要的操作
           public void singletonOperation(){
        
           }
    }

## 2.6测试类Client ##

### 2.6.1实现代码 ###

下面展示 `测试类的代码片`。

public class Client {
        
        public static void main(String[] args) {
        
            SingletonDemo1 s1 = SingletonDemo1.getInstance();
            SingletonDemo1 s2 = SingletonDemo1.getInstance();
            System.out.println(s1);
            System.out.println(s2);
    
            System.out.println(SingletonDemo5.INSTANCE==SingletonDemo5.INSTANCE);
    
        }
    }

### 2.6.2测试结果 ###

![在这里插入图片描述][20201110203546821.png_pic_center]

# 三、总结 #

主要：  
**饿汉式**：线程安全、调用效率高，但是，不能延时加载  
**懒汉式**：线程安全、调用效率不高，但是，可以延时加载  
其他：  
**双重检测锁式**：线程安全、调用效率高，可以延时加载（由于JVM底层内部模型原因，偶尔会出问题，不建议使用）  
**静态内部类式**：线程安全、调用效率高，但是，可以延时加载  
**枚举式**：线程安全、调用效率高、不能延时加载。并且可以天然防止反射和反序列化漏洞

**如何选用？**  
单例模式 占用资源少，不需要延时加载：枚举式好于饿汉式  
单例模式 占用资源大，需要延时加载： 静态内部类好于懒汉式

[20201110203546821.png_pic_center]: /images/20221120/bdbe9eec2b89477a9bfde741fa4b8e6f.png