单例设计模式

---

1、单例设计模式介绍

所谓类的单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个实例，并且该类是提供一个取得其对象实例的方法（静态方法）

---

1.1、单例设计模式八种方式

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

---

1.2、饿汉式（静态常量）

具体步骤：

1、构造器私有化（防止 new）
2、类的内部创建对象
3、向外暴露一个静态的公共方法。getInstance()；

代码如下（示例）：

package com.lhm.sigleton.type1;

/**
 * @ClassName SingletonTest01
 * @Description TODO
 * @Author liuHuiMin
 * @Date 2021/1/23 9:37
 */
public class SingletonTest01 {
    public static void main(String[] args) {

    }
}

/**
 * 饿汉式（静态变量）
 */
class Singleton{

    //1、私有化构造器，外部不能new
    private Singleton(){

    }

    //2、本类内部创建实例对象
    private final static Singleton singleton = new Singleton();

    //3、向外部暴露一个静态的公共方法
    public static Singleton getInstance(){
        return singleton;
    }

}

优点： 这种写法简单，就是在类装载的时候就完成了实例化。避免了线程同步问题。
缺点： 在类装载的时候就完成了实例，没有达到Lazy Loading效果。如果从始至终未使用这个实例，则会造成内存浪费。
结论： 这种单例模式可用，可能会造成内存浪费

---

1.3、饿汉式（静态代码块）

代码如下（示例）：

package com.lhm.sigleton.type2;

/**
 * @ClassName SingletonTest02
 * @Description TODO
 * @Author liuHuiMin
 * @Date 2021/1/23 9:49
 */
public class SingletonTest02 {
}

/**
 * 饿汉式（静态代码块）
 */
class Singleton {

    //1、私有化构造器，外部不能new
    private Singleton() {

    }

    //2、本类内部创建实例对象
    private static Singleton singleton;
    
    //在静态代码块中创建对象实例
    static {
        singleton = new Singleton();
    }

    //3、向外部暴露一个静态的公共方法
    public static Singleton getInstance() {
        return singleton;
    }
}

这种方式和上面的方式类似，只不过将实例化的过程放在了静态代码块中，也是在类装载的时候就执行静态代码块中的代码，初始化类的实例。优点、缺点和上面一样。也会可能造成浪费的情况。

---

1.4、懒汉式（线程不安全）

代码如下（示例）：

package com.lhm.sigleton.type3;

/**
 * @ClassName SingletonTest03
 * @Description TODO
 * @Author liuHuiMin
 * @Date 2021/1/23 10:11
 */
public class SingletonTest03 {
}

/**
 * 懒汉式（线程不安全）
 */
class Singleton{
    
    private Singleton(){
        
    }
    
    private static Singleton singleton;
    
    public static Singleton getInstance(){
         
        if(singleton == null){
            singleton = new Singleton();
        }
        
        return singleton;
    }
}

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

---

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

代码如下（示例）：

package com.lhm.sigleton.type04;

/**
 * @ClassName SingletonTest04
 * @Description TODO
 * @Author liuHuiMin
 * @Date 2021/1/23 10:18
 */
public class SingletonTest04 {
}

/**
 * 懒汉式（线程安全，同步方法）
 */
class Singleton{

    private Singleton(){

    }

    private static Singleton singleton;

    /**
     * 提供一个静态的共有方法，加入同步处理的代码synchronized，解决线程安全问题
     * @return
     */
    public static synchronized Singleton getInstance(){

        if(singleton == null){
            singleton = new Singleton();
        }

        return singleton;
    }
}

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

---

1.6、懒汉式（线程安全，同步代码块）

结论： 不能使用

---

1.7、双重检查

代码如下（示例）：

package com.lhm.sigleton.type06;

/**
 * @ClassName SingletonTest06
 * @Description TODO
 * @Author liuHuiMin
 * @Date 2021/1/23 10:28
 */
public class SingletonTest06 {
}

/**
 * 双重检查
 */
class Singleton{

    private Singleton(){

    }

    private static Singleton singleton;

    /**
     * 提供一个静态的共有方法，计入双重检查代码，解决了线程安全问题，同时解决懒加载问题
     * @return
     */
    public static synchronized Singleton getInstance(){

        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }

        return singleton;
    }
}

优点： Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if(singleton==null)检查，这样就可以保证线程安全了。实例代码只用执行一次，后面再次访问时，判断是否为空，直接返回实例化对象，也避免反复进行同步的方法。
结论： 实际开发中，推介使用这种单例设计模式。

---

1.8、静态内部类

代码如下（示例）：

package com.lhm.sigleton.type07;

/**
 * @ClassName SingletonTest08
 * @Description TODO
 * @Author liuHuiMin
 * @Date 2021/1/23 10:35
 */
public class SingletonTest08 {
}

/**
 * 静态内部类完成
 */
class Singleton{

    private Singleton(){

    }

    /**
     * 写一个静态内部类，该类中有一个静态属性SINGLETON
     */
    private static class SingletonInstance{
        private static final Singleton SINGLETON = new Singleton();
    }
    
    /**
     * 提供一个静态的共有方法，直接返回SingletonInstance.SINGLETON
     * @return
     */
    public static synchronized Singleton getInstance(){
        return SingletonInstance.SINGLETON;
    }
}

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

---

1.9、枚举

代码如下（示例）：

package com.lhm.sigleton.type08;

/**
 * @ClassName SingletonTest08
 * @Description TODO
 * @Author liuHuiMin
 * @Date 2021/1/23 10:45
 */
public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.SINGLETON;
        Singleton singleton2 = Singleton.SINGLETON;
        System.out.println(singleton == singleton2); //true
        
        System.out.println("singleton哈希码："+singleton.hashCode()); //1360875712
        System.out.println("singleton2哈希码："+singleton2.hashCode()); //1360875712
        singleton.sayOK();
    }
}

/**
 * 枚举
 */
enum Singleton{

    //属性
    SINGLETON;

    public void sayOK(){
        System.out.println("ok");
    }
}

优点： 借助JDK1.5中添加枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
结论： 强力推介使用。

---

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

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

---