【设计模式】单例模式

Kant101

已于 2022-11-20 00:30:37 修改

阅读量499

点赞数 1

分类专栏：设计模式文章标签：设计模式单例模式

于 2022-08-19 02:41:42 首次发布

本文链接：https://blog.csdn.net/qq_27198345/article/details/126416796

版权

设计模式专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1. 概述

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

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

2. 常见的几种单例模式写法

1) 饿汉式 —— 静态常量，线程安全

创建单例步骤

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

代码实现

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {
	
	/**
	 * 2. 本类内部创建对象实例
	 */
	private final static Singleton instance = new Singleton();

	/**
	 * 1. 构造器私有化，防止外部new
	 */
	private Singleton () {
	}

	/**
	 * 3. 向外暴露一个静态公共方法，用于获取单例对象
	 */
	public static Singleton getInstance() {
		return instance;
	}
}

优缺点说明
（1）优点：这种方法比较简单，就是在类装载的时候就完成实例化，避免了线程同步问题；
（2）缺点：在类装载的时候就完成实例化，没有达到 lazy loading 的效果。如果从始至终从未使用过这个单例，则会造成内存的浪费；
（3）这种方式基于classloader机制，避免了多线程的同步问题。不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方法（或者其他的静态方法）导致了类装载，这时候初始化instance就没有达到 lazy loading 的效果；
（4）结论：这种单例模式可用，可能造成内存的浪费。

2) 饿汉式 —— 静态代码块，线程安全

创建单例对象步骤

1）构造器私有化，防止外部new；

2）在静态代码块执行时，创建单例对象；

3）向外暴露一个静态公共方法，用于获取单例对象。

代码实现

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static Singleton instance;

    /**
     * 2. 在静态代码块执行时，创建单例对象
     */
    static {
        instance = new Singleton();
    }

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

	/**
     * 3. 向外暴露一个静态公共方法，用于获取单例对象
     */
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点说明

1）这种方式和上面的方式其实是类似的，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候就执行静态代码块中的代码，初始化类的实例。优点和缺点跟上面是一样的。

2）结论：这种单例模式可用，但是可能造成内存浪费。

3) 懒汉式 —— 非同步方法，线程不安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static Singleton instance;

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 提供了一个静态的公有方法，当使用到改方法时，才去创建 instance
     * 即懒汉式
     */
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点说明

1）起到了 Lazy Loading 的效果，但是只能在单线程下使用；

2）如果在多线程下，一个线程进入了 if (instance == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时就会产生多个实例。所以在多线程环境下不可使用这种方式；

3）结论：在实际开发中，不要使用这种方式。

4) 懒汉式 —— 同步方法，线程安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static Singleton instance;

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 加入了同步代码，解决了线程不完全问题
     */
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点说明

1）解决了线程不安全问题；

2）效率太低了，每个线程再想获得类的实例的时候，执行了 getInstance() 方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。对方法进行同步效率太低；

3）结论：在实际开发中，不推荐这种方式；

5) 懒汉式 —— 同步代码块，线程不安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static Singleton instance;

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 加入了同步代码，解决了线程不完全问题
     */
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

说明

这种方式是错误的，不能起到单例的作用，在实际开发中不会采用这种方式。

当一个线程执行了 if (instance == null) 就切换到了另外一个线程，这另外一个线程执行了创建单例对象的代码，释放了锁，当再切回前一个线程时，仍然会再进入同步代码块去执行创建单例对象的代码，这样就不是单例对象了，因此该法不可取。

6) 双重检查，线程安全

注意加了 volatile 关键字，防止未初始化完成读取不到instance。

创建单例对象步骤

1）构造器私有化，防止外部new对象；

2）提供了一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
同时保证了性能（推荐使用）；

package cn.edu.pku.singleton;
/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static volatile Singleton instance;

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 提供了一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
	 * 同时保证了性能（推荐使用）
     */
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

优缺点说明

1）Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (instance == null) 检查，这样就可以保证线程安全了；

2）这样，实例化代码只用执行一次，后面再次访问时，判断 if (instance == null)，直接 return 实例化对象，也避免了反复执行同步代码，保证了性能；

3）线程安全；延迟加载；性能较高；

4）结论：在实际开发中，推荐使用这种方式。

7) 静态内部类，线程安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 静态内部类，在调用 getInstance 方法时才会被加载，并且加载过程是线程安全的
     */
    private  static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优缺点说明

1）外部类被装载时，它里面的静态内部类不会被装载；

2）调用外部类的 getInstance() 方法时会导致静态内部类的装载，并且只会装载一次，而且在装载时是线程安全的；

3）既能达到懒加载的效果，同时也是线程安全的，推荐使用。

8) 枚举，线程安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/23
 */
public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
        System.out.println(instance1 == instance2);
    }
}

enum Singleton {
    /**
     * 属性
     */
    INSTANCE;
    public void say() {
        System.out.println("ok~");
    }
}