java设计模式 之 单例模式

单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

对于整个软件系统中，对于某个类而言，只能存在一个对象实例。

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

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。

缺点：

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

• 1、要求生产唯一序列号。
• 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
• 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

单例模式的几种实现方式

【小心使用】懒汉模式（三种）

懒汉式，线程不安全

class Singleton {
    private static Singleton instance;
    private Singleton(){}
    // 提供一个静态公有方法，懒汉：用到时才去创建 instance
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance; 
    }
}

优缺点：

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

结论：实际开发中不能使用这种方法。

懒汉式，线程安全 (使用synchronized)

1. 使用同步方法的形式。

解决了线程不安全问题，效率低下，所以在实际开发中也【不推荐】此方法。

class Singleton {
private static Singleton instance;
private Singleton(){}
// 提供一个静态公有方法，用到时才去创建 instance
// 使用 synchronized 关键字解决同步问题 ， 静态方法上的 synchronized 
// 关键字锁对象是 Singleton.class 所以每一次调用此方法 是都会进行同步，效率较低。
public static synchronized Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance; 
}
}

2. 使用同步代码块的方式。

【可以使用】饿汉式（两种实现方式）

1. （静态变量实现）

class Singleton {
 // 私有化构造器
 private Singleton() {}
 // 本类内部创建一个对象实例
 private final static Singleton instance = new Singleton();
 // 获取实例
 public Singleton getInstatce() {return instance;}
}

优点：

1. 写法简单，在类装载的时候完成了实例化。避免了线程同步问题。

缺点：

1. 在类加载的时候就完成实例化，没有达到Lazy Loading 的效果，如果从始至终从未使用过这个实例，则会造成内存的浪费。
2. 这种方式基于classloader机制避免多线程同步问题，不过，instance在类加载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类加载的原因有很多种，因此不能确定有其他的方式导致类加载，这时候初始化instance就没有达到lazy loading的效果。

结论：

​ 这种单例模式可能会造成内存的浪费。【如果整个程序代码中不使用，static 自动加载 则浪费资源】

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

class Singleton {
    // 私有化构造器
    private Singleton(){}
    // 本类内部创建对象实例
    private static Singleton instance;
    //静态代码块中创建单例对象
    static {
        instance = new Singleton();
    }
    // 提供一个公有获取方法
    public static Singleton getInstance() {
        return instance;
    }
}

优点与缺点：与静态变量实现相同。

【推荐使用】双检锁/双重检查

class Singleton {
    // 【重点】被volatile关键字修饰的变量，如果值发生了变更，其他线程立马可见，避免出现脏读的现象。
    private static volatile Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        // 【重点】
        if (singleton == null) { // 第一次检查
            // 可能多个线程进入此处
            synchronized (Singleton.class) {
                // 仅一个线程进入 volatile关键字对更改关注
                if (singleton == null) { // 第二次检查
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

【推荐使用】静态内部类实现单例模式

静态内部类特点：

1. 类装载的时候线程是安全，保证了初始化实例时只有一个线程，避免了线程同步的问题。

2. 外部类装载时并不会导致静态内部类加载，只有在方法使用到内部类时才会类加载内部类。效率高。

class Singleton {
    // 私有化构造方法
    private Singleton() {}
    // 静态内部类中 有 单例常量
    private static class SingleTonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    // 通过调用内部类静态常量，类加载内部类,获取内部类中的常量--获取单例
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

【java作者推荐】使用枚举实现单例模式

Enum 使用枚举来实现单例模式，不仅能避免多线程问题，而且能防止反序列化重新创建新的对象。

enum Singleton {
    INSTANCE; // 属性
    public void sayOK() {
        Sytem.out.pringln("OK");
    }
}

public static void main(String[] args) {
    Singleton instance = Singleton.INSTANCE;
    Singleton instance1 = Singleton.INSTANCE;
    // instance == instance1
}

JDK 中使用单例模式的栗子

Runtime.class 中 使用了单例模式：

public class Runtime {
    // 使用 饿汉模式 静态变量创建
    private static Runtime currentRuntime = new Runtime();
    
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    
    private Runtime() {}
    
}

意图

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

一共有八种单例模式。。。