单例模式

单例模式是属于创建者模式；创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。创建者模式分为：

1.单例模式 2.工厂方法模式 3.抽象工程模式 4.原型模式 5.建造者模式

单例模式：（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。单例模式结构：（单例类，访问类）

实现：（饿汉式/懒汉式）

饿汉式：类加载就会导致该单实例对象被创建

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

案例1.1 饿汉式（静态变量方法创建）

public class Singleton {

//    私有构造方法
    private Singleton(){}

//    创建实例对象
    private static Singleton instance = new Singleton();
    
//    提供公共访问方法
    public static Singleton getInstance(){
        return instance;
    }
}

注意：该代码是饿汉式会随着类的创建而创建如果代码多，会浪费空间

案例1.2 饿汉式（静态代码块方法） `

    /**
     * 单例模式 饿汉式 静态代码块方法
     * */
//    私有构造方法
    private Singleton(){}
    //在成员位置创建该类的对象
    private static Singleton instance;
    static {
        instance = new Singleton();
    }
    //    提供公共访问方法
    public static Singleton getInstance(){
        return instance;
    }

注意：对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的案例1.1基本上一样，当然该方式也存在内存浪费问题。

案例1.3 懒汉式 (线程不安全)

/**
 * 单例模式 懒汉式 线程不安全
 * */

private Singleton(){}

//在成员位置创建该类的对象
private static Singleton instance;

//    提供公共访问方法
public static Singleton getInstance(){
    if(instance == null){
        instance = new Singleton();
    }
    return instance;
}

注意：根据代码可以知道当instance==null 时，创建一个新的instance ，如果走到一半，让别的线程抢去了，就可能会创建多个实例（可以加上锁）

案例1.4 懒汉式 (线程安全)

/**
 * 单例模式 懒汉式 线程安全 效率不行
 * */

private Singleton(){}

//在成员位置创建该类的对象
private static Singleton instance;

//    提供公共访问方法
public synchronized static Singleton getInstance(){
    if(instance == null){
        instance = new Singleton();
    }
    return instance;
}

线程安全了，但是效率下降了，因为到synchronized 是锁住了整个代码块（整个方法）。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

案例1.5 懒汉式（双重检查锁）重要

    /**
     * 单例模式  懒汉式  双重检查锁
     * */
//    提供私有构造方法
    private Singleton(){}

    private static Singleton singleton;

    public static Singleton getInstance(){
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(singleton == null){
            synchronized (Singleton.class){
                //抢到锁之后再次判断是否为null
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

//    提供私有构造方法
    private Singleton(){}

    private static volatile Singleton singleton;

    public static Singleton getInstance(){
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(singleton == null){
            synchronized (Singleton.class){
                //抢到锁之后再次判断是否为null
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

案例 1.6 懒汉式静态内部类方式

静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

//私有构造方法
private Singleton() {}

private static class SingletonHolder {
    private static final Singleton INSTANCE = new Singleton();
}

//对外提供静态方法获取该对象
public static Singleton getInstance() {
    return SingletonHolder.INSTANCE;
}

静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

案例 1.7 饿汉式枚举方式

public enum Singleton { INSTANCE; }

枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

破坏单例模式方式

以上的案例可以创建多个对象（除枚举方式外），序列化和反射

当使用序列化和反射时，会破坏单例模式（枚举不会）这里就不演示了，直接上解决办法

序列化方式解决

public class Singleton implements Serializable {
//    私有构造方法
    private Singleton(){}

    private static volatile Singleton singleton;

    public static Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    /**
     * 下面是为了解决序列化反序列化破解单例模式
     */
    private Object readResolve() {
        return singleton;
    }


}

readResolve() 是 Java 中的一个方法，它允许类在反序列化时控制返回的对象。它在对象从流中反序列化后被调用，可以用来确保只创建一个类的实例。通过返回特定的对象实例，readResolve() 可以防止创建重复的对象，并确保对象的状态保持一致。

反射方式问题解决

private Singleton(){
     /*
       反射破解单例模式需要添加的代码
    */
    if(singleton != null){
        throw new RuntimeException();
    }
}

private static volatile Singleton singleton;

public static Singleton getInstance(){
    if(singleton == null){
        synchronized (Singleton.class){
            if(singleton == null){
                singleton  = new Singleton();
            }
        }
    }
    return singleton;
}

这种方式比较好理解。当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。

设计模式---单例模式

单例模式

破坏单例模式 方式

破坏单例模式方式