设计模式之单例模式

2022-03-09 22:38 由 pluto_charon 发表于 #软件设计

介绍：

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

比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象，SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够了，这是就会使用到单例模式。

比如，在一个系统中需要掉用外部系统的类，一般需要创建一个外部对象的连接对象，这个对象也可以设计成单例模式。

单例模式的类型：

饿汉式（静态常量）
饿汉式（静态代码块）
懒汉式（线程不安全）
懒汉式（线程安全，同步方法）
懒汉式（线程安全，同步代码块）
双重检查
静态内部类
枚举(之前写的关于枚举的博客)

代码实例：

1.饿汉式（静态常量）

优点：写法简单，就是在类装载的时候就完成实例化，避免了线程同步的问题

缺点：在类装载的时候就完成实例化，没有达到懒加载的效果，如果从始至终从未使用过这个实例，则会造成内存浪费

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多，因此不能确定有其他的方式导致类装载，这时候初始化instance就没有达到懒加载的效果

package com.charon.singlecase.type1;

/**
 * @className: Singleton01
 * @description: 饿汉式  如jdk中的Runtime类
 * @author: charon
 * @create: 2022-03-05 23:09
 */
public class Singleton01 {

    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

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

    /**
     * 提供一个工有的静态方法，返回实例对象
     * @return
     */
    public static Singleton getInstance(){
        return instance;
    }
}

2.饿汉式（静态代码块）

与上面的方式类似，只不过将实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。

package com.charon.singlecase.type2;

/**
 * @className: Singleton02
 * @description: 饿汉式（静态变量）
 * @author: charon
 * @create: 2022-03-05 23:22
 */
public class Singleton02 {

    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static Singleton instance;

    /**
     * 在静态代码块中创建单例对象
     */
    static{
        instance = new Singleton();
    }

    /**
     * 提供一个工有的静态方法，返回实例对象
     * @return
     */
    public static Singleton getInstance(){
        return instance;
    }
}

3.懒汉式（线程不安全）

起到了懒加载的效果，但是只能在单线程下使用，如果多线程情况下，一个线程进入了if(instance == null )判断语句，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下不可使用这种方式。

package com.charon.singlecase.type3;

/**
 * @className: Singleton03
 * @description:
 * @author: charon
 * @create: 2022-03-06 15:51
 */
public class Singleton03 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static Singleton instance;

    /**
     * 提供一个公有的静态方法，当使用到该方法时，采取创建instance
     * @return
     */
    public static Singleton getInstance(){
        if(instance == null ){
            instance = new Singleton();
        }
        return instance;
    }
}

4.懒汉式（线程安全，同步方法）

解决了线程不安全的问题，但是效率太低了，每个线程在获得类的实例的时候，执行getInstance()方法都要进行同步，而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行。

package com.charon.singlecase.type4;

/**
 * @className: Singleton04
 * @description:
 * @author: charon
 * @create: 2022-03-06 15:51
 */
public class Singleton04 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static Singleton instance;

    /**
     * 提供一个公有的静态方法，当使用到该方法时，采取创建instance
     * 加入synchronized同步处理的关键字，解决线程安全的问题
     * @return
     */
    public static synchronized Singleton getInstance(){
        if(instance == null ){
            instance = new Singleton();
        }
        return instance;
    }
}

5.懒汉式（线程安全，同步代码块）

这种方式，本意是想对第四种实现方式进行改进，因为前面同步方法的颗粒度太大，因此改为同步产生实例化的代码块。

但是这种同步并不能起到线程同步的作用，跟第三种实现方式遇到的情形一致，加入一个线程进入了if(instance == null )判断语句，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例

package com.charon.singlecase.type5;

/**
 * @className: Singleton05
 * @description:
 * @author: charon
 * @create: 2022-03-06 16:16
 */
public class Singleton05 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static Singleton instance;

    /**
     * 提供一个公有的静态方法，当使用到该方法时，采取创建instance
     * 加入synchronized同步处理的关键字，解决线程安全的问题
     * @return
     */
    public static Singleton getInstance(){
        if(instance == null ){
            synchronized(Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}

6.双重检查（推荐使用）

双重检查是多线程开发中常使用到的，在代码中，保证了线程安全。并且，实例化代码只用执行一次，后面再次访问时，判断if(instance == null )，直接return实例化对象，也避免了反复进行方法同步。

package com.charon.singlecase.type6;

/**
 * @className: Singleton06
 * @description:
 * @author: charon
 * @create: 2022-03-06 16:22
 */
public class Singleton06 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static volatile Singleton instance;

    /**
     * 提供一个公有的静态方法，当使用到该方法时，采取创建instance
     * 加入双重检查代码，解决线程安全的问题，同时解决了懒加载的问题，并保证效率
     * @return
     */
    public static Singleton getInstance(){
        if(instance == null ){
            synchronized(Singleton.class){
                if (instance == null ){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

7.静态内部类（推荐使用）

采用了类装载机制来保证初始化实例时只有一个线程。在当外部类被装载的时候，静态内部类不会被装载。当需要用的时候，才会装载静态内部类，而类的静态属性只会在第一次加载类的时候初始化。所以这里是jvm的类装载机制保证了线程安全。

package com.charon.singlecase.type7;

/**
 * @className: Singleton07
 * @description: 使用静态内部类完成单例模式
 * @author: charon
 * @create: 2022-03-06 16:29
 */
public class Singleton07 {

    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 静态内部类
     */
    private static class SingletonInstance{
        public static final Singleton INSTANCE = new Singleton();
    }

    /**
     * 提供一个公有的静态方法，直接返回SingletonInstance.INSTANCE
     * @return
     */
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

注意事项和细节说明：

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

热门相关：这个人仙太过正经网游之逆天飞扬网游之逆天飞扬寂静王冠大神你人设崩了