Java设计模式--单例模式（懒汉式实现）

1、单例模式（Singleton Pattern）

        单例模式是一种常见的设计模式，目的是确保一个类只会存在一个实例，并且该类提供全局进行访问此实例的方法。

2、懒汉式

/**
 * @author Hao
 * 单例模式：懒汉式
 * 懒汉式是线程不安全的，懒汉式在多线程环境下，可能会出现多个实例，所以需要加锁。
 * 懒汉式可以延迟加载，不会在首次加载时就初始化，而是在调用时才创建。
 *
 * 总结：
 *     优点：延迟加载，减少内存开销。
 *     缺点：在多线程环境下，可能会出现多个实例。
 */

 2.1、方法一：双重检查锁

// 方法一：双重检查锁

// -------------------------方法一开始-------------------------

// 私有化定义实例
private static volatile SingletonLazy instance;

/**
 * 提供公共获取实例方法
 * @return SingletonLazy 实例
 * 使用双重判断加锁，而不直接于方法上加锁，是为了避免每次调用getInstance()方法时，
   都进行加锁，造成不必要的开销。
 */
public static SingletonLazy getInstance(){
    // 第一次判断，判断是否已经实例化，如果已经实例化，那么就不会被多线程影响
        出现创建多个实例的情况，所以直接返回
    if (instance == null){
        // 如果没有实例化，那么就加锁，避免多线程下，多个线程同时创建实例的情况
        synchronized (SingletonLazy.class){
            // 此时进行第二次判断，避免多个线程同时访问抢锁，导致创建多个实例。举个例子
            // 线程a、b同时访问，此时instance还未实例化。那么此时线程a、b都会通
                过第一次判断。
            // 这时线程a率先强到锁，如果不进行二次判断，线程a创建实例后，线程b获得锁
                也会创建实例，从而造成多个实例。
            if (instance == null){
                instance = new SingletonLazy();
            }
        }
    }
    return instance;
}

// -------------------------方法一结束-------------------------

2.2、方法二： 静态内部类

// 方法二：静态内部类

// -------------------------方法二开始-------------------------

// 创建私有内部类，提供实例
private static class SingletonHolder{
    private static final SingletonLazy instance = new SingletonLazy();

}

/**
 * 提供公共获取实例方法
 * @return SingletonLazy 实例
 *
 * 使用静态内部类，避免了线程不安全，延迟加载，效率更高。
 * 静态内部类在第一次使用的时候才会被加载，不会造成内存浪费。
 */
public static SingletonLazy getSingleton(){
    return SingletonHolder.instance;
}

// -------------------------方法二结束-------------------------

2.3、方法三：枚举类

/**
 * @author Hao
 *
 * 通过枚举方式创建
 */
public enum Singleton {

    // 没错就是这么简单 =.=，而且枚举的实例化是线程安全的、不会被破坏的。
    INSTANCE;

    private String name;

    public String getName() {
        return name;
    }

}

 3、完整代码

/**
 * @author Hao
 * 单例模式：懒汉式
 * 懒汉式是线程不安全的，懒汉式在多线程环境下，可能会出现多个实例，所以需要加锁。
 * 懒汉式可以延迟加载，不会在首次加载时就初始化，而是在调用时才创建。
 *
 * 总结：
 *     优点：延迟加载，减少内存开销。
 *     缺点：在多线程环境下，可能会出现多个实例。
 */
public class SingletonLazy {

    // 私有化构造函数
    private SingletonLazy(){}

    // 方法一：双重检查锁

    // -------------------------方法一开始-------------------------

    // 私有化定义实例
    private static volatile SingletonLazy instance;

    /**
     * 提供公共获取实例方法
     * @return SingletonLazy 实例
     * 使用双重判断加锁，而不直接于方法上加锁，是为了避免每次调用getInstance()方法时，都进行加锁，造成不必要的开销。
     */
    public static SingletonLazy getInstance(){
        // 第一次判断，判断是否已经实例化，如果已经实例化，那么就不会被多线程影响出现创建多个实例的情况，所以直接返回
        if (instance == null){
            // 如果没有实例化，那么就加锁，避免多线程下，多个线程同时创建实例的情况
            synchronized (SingletonLazy.class){
                // 此时进行第二次判断，避免多个线程同时访问抢锁，导致创建多个实例。举个例子
                // 线程a、b同时访问，此时instance还未实例化。那么此时线程a、b都会通过第一次判断。
                // 这时线程a率先强到锁，如果不进行二次判断，线程a创建实例后，线程b获得锁也会创建实例，从而造成多个实例。
                if (instance == null){
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }

    // -------------------------方法一结束-------------------------



    // -----------------------------------------------------------------------------------------------------------------



    // 方法二：静态内部类

    // -------------------------方法二开始-------------------------

    // 创建私有内部类，提供实例
    private static class SingletonHolder{
        private static final SingletonLazy instance = new SingletonLazy();

    }

    /**
     * 提供公共获取实例方法
     * @return SingletonLazy 实例
     *
     * 使用静态内部类，避免了线程不安全，延迟加载，效率更高。
     * 静态内部类在第一次使用的时候才会被加载，不会造成内存浪费。
     */
    public static SingletonLazy getSingleton(){
        return SingletonHolder.instance;
    }

    // -------------------------方法二结束-------------------------

}

4、饿汉式

Java设计模式--单例模式（饿汉式实现）-优快云博客