@TOC

创建型模式

单例（Singleton）

解决访问创建对象的问题

描述

确保一个类只有一个实例，并提供了一个全局访问点，使得各个部分能够方便地共享该实例。这种方式可以避免重复创建对象，减少系统开销，并且提高了代码的可读性和可维护性。

适用环境

系统中某个类只能有一个实例对象，且该实例需要提供全局访问点。需要确保某个实例对象只被创建一次，并在系统中被广泛使用。

优点：

保证了系统中某个类只有一个实例对象，并且提供了全局访问点。减少了对象创建和销毁的开销，节省了系统资源。

缺点：

单例模式会导致单例类的职责过重，在一定程度上违反了单一职责原则。单例模式在多线程环境下可能存在线程安全问题。

违反原则

可能违反单一职责原则：一个类既负责自己的业务逻辑，又负责管理自己的实例化。

代码实现

四种不同类型的单例模式：饿汉式、懒汉式、双重检查锁和枚举
为了汇总测试，通过Main方法创建两个实例来检查它们是否是同一个对象

public class testSingleton {
    
    
    public static void main(String[] args) {
    
    
        Singleton1 s1 = Singleton1.getInstance();
        Singleton1 s2 = Singleton1.getInstance();
        System.out.println(s1 == s2); // true

        Singleton2 s3 = Singleton2.getInstance();
        Singleton2 s4 = Singleton2.getInstance();
        System.out.println(s3 == s4); // true

        Singleton3 s5 = Singleton3.getInstance();
        Singleton3 s6 = Singleton3.getInstance();
        System.out.println(s5 == s6); // true

        Singleton4 s7 = Singleton4.INSTANCE;
        Singleton4 s8 = Singleton4.INSTANCE;
        System.out.println(s7 == s8); // true
    }
}

// 饿汉式单例模式
class Singleton1 {
    
    
    private static Singleton1 instance = new Singleton1();
    private Singleton1() {
    
    }
    public static Singleton1 getInstance() {
    
    
        return instance;
    }
}

// 懒汉式单例模式
class Singleton2 {
    
    
    private static Singleton2 instance;
    private Singleton2() {
    
    }
    public static synchronized Singleton2 getInstance() {
    
    
        if (instance == null) {
    
    
            instance = new Singleton2();
        }
        return instance;
    }
}

// 双重检查锁单例模式
class Singleton3 {
    
    
    private volatile static Singleton3 instance;
    private Singleton3() {
    
    }
    public static Singleton3 getInstance() {
    
    
        if (instance == null) {
    
    
            synchronized (Singleton3.class) {
    
    
                if (instance == null) {
    
    
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }
}

// 枚举单例模式
enum Singleton4 {
    
    
    INSTANCE;
}

饿汉模式

饿汉式初始化在类加载时创建单例类的实例。这确保了实例始终可用且线程安全，但如果实例不总是需要，则可能会浪费资源。

// 饿汉式单例模式
class Singleton1 {
    
    
    private static Singleton1 instance = new Singleton1();
    private Singleton1() {
    
    }
    public static Singleton1 getInstance() {
    
    
        return instance;
    }
}

懒汉模式

懒汉式初始化仅在需要时创建单例类的实例。这样可以节省资源，但如果没有同步，则不是线程安全的。

// 懒汉式单例模式
class Singleton2 {
    
    
    private static Singleton2 instance;
    private Singleton2() {
    
    }
    public static synchronized Singleton2 getInstance() {
    
    
        if (instance == null) {
    
    
            instance = new Singleton2();
        }
        return instance;
    }
}

双重检查锁

双重检查锁是懒汉式初始化的线程安全版本，它避免了在创建实例后的第一次同步。

// 双重检查锁单例模式
class Singleton3 {
    
    
    private volatile static Singleton3 instance;
    private Singleton3() {
    
    }
    public static Singleton3 getInstance() {
    
    
        if (instance == null) {
    
    
            synchronized (Singleton3.class) {
    
    
                if (instance == null) {
    
    
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }
}

枚举单例

枚举单例模式是一种简单的线程安全单例模式

// 枚举单例模式
enum Singleton4 {
    
    
    INSTANCE;
}