设计模式：单例模式介绍及8种写法（饿汉式、懒汉式、Double Checked Locking、静态内部类、枚举）

心已赠人 2022-11-25 13:18 24阅读 0赞

### 单例模式 ###

*   *  0、介绍
     *  一、饿汉式（静态常量）
     *  二、饿汉式（静态代码块）
     *  三、懒汉式（线程不安全）
     *  四、懒汉式（线程安全，同步方法）
     *  五、懒汉式（同步代码块）
     *  六、 双重检查Double Checked Locking
     *  七、静态内部类
     *  八、枚举
     *  九、总结
     *  十、单例模式在JDK里的应用

## 0、介绍 ##

单例模式，就是采用一定方法，保证整个软件系统里，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（这种方法一般是静态的）。

单例模式在实际开发中有 5 种写法+加 3 种。

1.  饿汉式（静态常量）
2.  饿汉式（静态代码块）
3.  懒汉式（线程不安全）
4.  懒汉式（线程安全，同步方法）
5.  懒汉式（线程安全，同步代码块）
6.  双重检查
7.  静态内部类
8.  枚举

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

这种饿汉式的单例模式构造的步骤如下：

1.  构造器私有化；（防止用new来得到对象实例）
2.  类的内部创建对象；（因为1，所以2）
3.  向外暴露一个静态的公共方法；（getInstance）

示例：

class Singleton{
        
        //1私有化构造方法
        private Singleton(){
        
    
        }
        //2创建对象实例
        private final static Singleton instance = new Singleton();
        //3对外提供公有静态方法
        public static Singleton getInstance(){
        
            return instance;
        }
    }

这样的话，获取对象就不能通过 new 的方式，而要通过 Singleton.getInstance()；并且多次获取到的都是同一个对象。

使用静态常量的饿汉式写法实现的单例模式的优缺点：

**优点：**

**简单**，类装载的时候就完成了实例化，避免了多线程同步的问题。

**缺点：**

类装载的时候完成实例化，没有达到 Lazy Loading （懒加载）的效果，如果从始至终都没用过这个实例呢？那就会造成**内存的浪费**。（大多数的时候，调用getInstance方法然后类装载，是没问题的，但是导致类装载的原因有很多，可能有其他的方式或者静态方法导致类装载）

**总结：**

如果确定会用到他，这种写**是没问题的**，但是尽量避免内存浪费。

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

和上一种用静态常量的方法类似，是把创建实例的过程放在静态代码块里。

class Singleton{
        
        //1同样私有化构造方法
        private Singleton(){
        
    
        }
        //2创建对象实例
        private static Singleton instance;
        //在静态代码块里进行单例对象的创建
        static {
        
            instance = new Singleton();
        }
        //3提供静态方法返回实例对象
        public static Singleton getInstance() {
        
            return instance;
        }
    }

**优缺点**：和上一种静态常量的方式一样；

**原因**：实现本来就是和上面的一样，因为类装载的时候一样马上会执行静态代码块中的代码。

## 三、懒汉式（线程不安全） ##

上面的两种饿汉式，都是一开始类加载的时候就创建了实例，可能会造成内存浪费。

懒汉式的写法如下：

class Singleton{
        
        private static Singleton instance;
        private Singleton(){
        
    
        }
        //提供静态公有方法，使用的时候才创建instance
        public static Singleton getInstance(){
        
            if(instance == null){
        
                instance = new Singleton();
            }
            return  instance;
        }
    }

也就是说，同样是 1) 私有构造器；2) 类的内部创建实例；3) 向外暴露获取实例方法。这三个步骤。

但是懒汉式的写法，将创建的代码放在了 getInstance 里，并且只有第一次的时候会创建，这样的话，类加载的过程就不会创建实例，同时也保证了创建只会有一次。

**优点：**

起到了Lazy Loading 的作用

**缺点：**

但是只能在单线程下使用。如果一个线程进入了 if 判断，但是没来得及向下执行的时候，另一个线程也通过了这个 if 语句，这时候就会产生多个实例，所以多线程环境下不能使用这种方式。

**结论：**

实际开发**不要用**这种方式。

## 四、懒汉式（线程安全，同步方法） ##

因为上面说了主要的问题，就在于 if 的执行可能不同步，所以解决的方式也很简单。

class Singleton{
        
        private static Singleton instance;
        private Singleton(){
        
    
        }
        //使用的时候才创建instance,同时加入synchronized同步代码，解决线程不安全问题
        public static synchronized Singleton getInstance(){
        
            if(instance == null){
        
                instance = new Singleton();
            }
            return  instance;
        }
    }

只要在获取实例的静态方法上加上 synchronized 关键字，同步机制放在getInstance方法层面，就 ok。

**优点：**

保留了单例的性质的情况下，解决了线程不安全的问题

**缺点：**

**效率太差**了，每个线程想要获得类的实例的时候都调用 getInstance 方法，就要进行同步。  
然而这个方法本身执行一次实例化代码就够了，后面的想要获得实例，就应该直接 return ，而不是进行同步。

**结论：**

实际开发仍然**不推荐**。

## 五、懒汉式（同步代码块） ##

这种写法是基于对上一种的思考，既然在方法层面效率太差，那直接在实例化的语句上加 synchronized 来让他同步，是不是就能解决效率问题呢？

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

事实上，这种方法，让 synchronized 关键字放入方法体里，又会导致可能**别的线程同样进入 if 语句**，回到了第三种的问题，所以来不及同步就会产生线程不安全的问题。

**结论**：不可用

## 六、 双重检查Double Checked Locking ##

在下面的实例化过程里采用 double check locking，也就是两次判断。

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;
        }
    }

> 4 的懒汉式同步方法写法里，getInstance方法是用了synchronized修饰符，所以虽然解决了 lazy loading 的问题，线程也安全，但是同步起来会很慢。

> 而 5 的懒汉式同步代码块写法，将 synchronized 修饰符加到内部的代码块部分，又会导致线程安全直接失效，因为可能大家都同时进入了 getInstance 方法。

所以double - checked - locking 将两者相结合。

可是这样的 double - checked - locking **还不能保证线程安全**，原因涉及到多线程里的知识点，指令重排序：（待更新链接）

看起来只有一句的 instance = new Singleton(); 实际上是分为三个步骤的：

1). 申请一块内存空间，用来装 new 出来的对象；  
2). 初始化对象信息；  
3). 返回对象地址，建立连接。

而这些指令可能由于重排，先执行了第 3 步，而第 2 步由于耗时过多还在进行，此时另一个线程执行，虽然判断出了 instance 不为空，可是他直接返回的对象是return instance，这块地址的内容是不对的，可能是空指针，可能是错误的数据。

**解决这个终极问题的方式是，使用 volatile 关键字，让修改值立即更新到主存。**

class Singleton{
        
        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;
        }
    }

**优点**：

double-check是多线程开发里**经常用到**的，满足了我们需要的线程安全&&避免反复进行同步的效率差&&lazy loading。

**结论**：推荐使用。

## 七、静态内部类 ##

静态内部类：用static修饰的内部类，称为静态内部类，完全属于外部类本身，不属于外部类某一个对象，外部类不可以定义为静态类，Java中静态类只有一种，那就是静态内部类。

class Singleton{
        
        //构造器私有化
        private Singleton(){
        
    
        }
        //一个静态内部类，里面有一个静态属性，就是实例
        private static class SingletonInstance{
        
            private static final Singleton instance = new Singleton();
        }
        //静态的公有方法
        public static Singleton getInstance(){
        
            return SingletonInstance.instance;
        }
    }

核心：

1.  静态内部类在外部类装载的时候并不会执行，也就是满足了 lazy loading；
2.  调用getInstance的时候会取属性，此时才加载静态内部类，而 jvm 底层的类装载机制是线程安全的，所以利用 jvm 达到了我们要的线程安全；
3.  类的静态属性保证了实例化也只会进行一次，满足单例。

结论：推荐。

## 八、枚举 ##

将单例的类写成枚举类型，直接只有一个Instance变量。

enum Singleton{
        
        instance;
        public void sayOk(){
        
            System.out.println("ok");
        }
    }

调用的时候也不用new，直接用Singleton.instance，拿到这个属性。（一般INSTANCE写成大写）

**优点：**

满足单例模式要的特点，同时还能够避免反序列化重新创建新的对象。  
这种方法是effective java作者提供的方式。

\*\*结论：\*\*推荐。

## 九、总结 ##

**单例模式使用的场景是**：

需要频繁创建和销毁的对象、创建对象耗时过多或耗资源太多（重型对象）、工具类对象、频繁访问数据库或者文件的对象（数据源、session工厂等），都应用单例模式去实现。

因为单例模式保证了系统内存中只存在该类的一个对象，所以能节省资源，提高性能，那么对外来说，单例的类都不能再通过 new 去创建了，而是采用类提供的获取实例的方法。

上面的八种写法里面：饿汉式两种基本是一样的写法，懒汉式三种都有问题，以上物种的改进就是双重检查，另辟蹊径的是静态内部类和枚举。

所以，单例模式推荐的方式有四种：

1.  饿汉式可用（虽然内存可能会浪费）；
2.  双重检查；
3.  静态内部类；
4.  枚举。

## 十、单例模式在JDK里的应用 ##

Runtime类就是一个单例模式的类，并且可以看到，他是采用我们所说的第一种方式，即饿汉式（静态常量的方式）

1.  私有构造器；
2.  静态常量，类的内部直接将类实例化；
3.  提供公有的静态方法。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA5Mjc4Nw_size_16_color_FFFFFF_t_70]: /images/20221124/4cb57692902347c6a251ea9248aa5b54.png