Java设计模式--单例模式

概述

单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)；

单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂等）；

单例模式的八种实现方式（4 和 5 其实一样，其中双重检查很重要）：

1. 饿汉式(静态常量)
2. 饿汉式（静态代码块）
3. 懒汉式(线程不安全)
4. 懒汉式(线程安全，同步方法)
5. 懒汉式(线程安全，同步代码块)
6. 双重检查
7. 静态内部类
8. 枚举

---

饿汉式（静态常量）

1. 构造器私有化 (防止外部直接去 new ) ；
2. 在对应类的内部创建对象 ；
3. 向外暴露一个静态的公共方法（如：getInstance() 方法）；

//饿汉式（静态常量）
class Singleton{
    //1. 构造器私有化
    private Singleton(){}

    //2. 本类内部创建对象实列
    private final static Singleton instance = new Singleton();

    //3. 对外提供一个公有的静态方法并返回实列对象
    public static Singleton getInstance(){
        return instance;
    }
}

优点

• 这种写法比较简单，就是在类装载的时候就完成实例化，并且避免了线程同步问题；

缺点

• 在类加载的时候就完成实例化，没有达到 Lazy Loading （懒加载）的效果；如果从始至终从未使用过这个实例，则会造成内存的浪费；

因此，这种单例模式是可用，但可能造成内存浪费；

---

饿汉式（静态代码块）

//饿汉式（静态代码块）
class Singleton {
    //1. 构造器私有化
    private Singleton() {}
    
    //2. 静态代码块创建对象
    private static Singleton instance;
    static {
        instance = new Singleton();
    }

    //3. 对外提供一个公有的静态方法并返回实列对象
    public static Singleton getInstance() {
        return instance;
    }
}

这种单例模式是可用，但可能造成内存浪费；

---

懒汉式（线程不安全）

//懒汉式（线程不安全）
class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
        //如果为空采取创建对象实列
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

多线程情况下可能会生成多个对象实列，在实际开发中，不要使用这种方式；

---

懒汉式（线程安全）

class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    //使用 synchronized 关键字来解决线程安全问题
    public synchronized static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

解决了线程不安全问题，但是效率太低了，每个线程在想获得类的实例时候，执行 getInstance() 方法都要进行同步，而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例， 直接 return 就行了；

在实际开发中，不推荐使用这种方式；

或者将上述的代码修改为同步代码块的形式，如下面代码；但是，改代码还不是一个线程安全的；

class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    //使用 synchronized 关键字来解决线程安全问题
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}

不能使用该方法；

---

双重检查（线程安全）

//双重检查
class Singleton {
    private static volatile Singleton instance;
    private Singleton() {
    }
    //解决线程安全以及懒加载问题
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

线程安全；延迟加载；效率较高；在实际开发中，推荐使用这种单例设计模式；

---

静态内部类（线程安全）

//静态内部类
class Singleton {
    private static Singleton instance;
    private Singleton(){}
    
    //第一次使用时才会被加载（非静态内部类也是一样）
    private static class SingletonInner{
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance(){
        return instance = SingletonInner.INSTANCE;
    }
}

避免了线程不安全，利用静态内部类特点实现延迟加载，效率高，推荐使用；

---

枚举

public class Singleton08 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1 == instance2);//true
    }
}
//枚举实现单列
enum Singleton {
    INSTANCE;
    public void test(){
        System.out.println("SUCCESS");
    }
}

---