23种设计模式1_单例模式

1 基本介绍

单例模式：采取一定的方法保证在整个的软件系统中，对某个类***只能存在一个对象实例***，并且该类只提供一个取得其对象实例的方法。比如：SessionFactory

2 饿汉式

2.1 实现步骤

​ ① 构造器私有化

​ ② 类的内部创建对象

​ ③ 向外暴露一个静态的公共方法

2.2 代码演示

2.2.1 方式一

public class Singleton {
    // 1.构造器私有化
    private Singleton() {}
    
    // 2.类的内部创建对象
    private final static Singleton instance = new Singleton();
    
    // 3.向外暴露一个静态的公共方法
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点：

① 这种写法简单，就是在类装载的时候就完成了实例化，避免了在多线程中的同步问题。

② 在类装载的时候就完成实例化，如果从始至终都没有用过这个实例，则会造成内存的浪费。

2.2.2 方式二

public class Singleton {
    // 1.构造器私有化
    private Singleton() {}
    
    // 2.类的内部创建对象
    private static Singleton instance;
    // 在静态代码块中创建单例对象
    static {
        instance = new Singleton();
    }
    
    // 3.向外暴露一个静态的公共方法
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点：与方式一类似，也是在类装载的时候执行静态代码块中的代码，初始化类的实例，避免线程同步问题，但是也可能造成内存浪费。

3 懒汉式

3.1 方式一

public class Singleton {
    private static Singleton instance;
    private Singleton {}
    
    // 懒汉式：提供一个静态方法，当使用该方法时才创建实例对象
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

缺点：存在线程安全问题，适用于单线程，现实开发中，不建议使用这种方式

3.2 方式二（线程安全）

public class Singleton {
    private static Singleton instance;
    private Singleton {}
    
    // 懒汉式：提供一个静态方法，当使用该方法时才创建实例对象
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

分析：解决了线程不安全的问题，但是降低了同步效率，第一次需要进行初始化，后面就可以直接return。

3.3 方式三

public class Singleton {
    private static Singleton instance;
    private Singleton {}
    
    // 懒汉式：提供一个静态方法，当使用该方法时才创建实例对象
    public static Singleton getInstance() {
        if (instance == null) {
            // 加入多个线程同时进入了该判断，就会实例化多个，不是线程安全的了
        	synchronized (Singleton.class) {
            	instance = new Singleton();
            }
        }
        return instance;
    }
}

分析：线程不安全，现实开发中不能这样使用

3.4 方式四（线程安全）

// Double Check
public 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;
    }
}

分析：线程安全，延迟加载，效率较高，推荐使用。

4 静态内部类

代码演示：

class Singleton {
	private Singleton() {}
	
	private static class SingletonInstance {
		private static final Singleton INSTANCE = new Singleton();
	}
    
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE
    }
}

分析：

① 当类Singleton装载的时候，静态内部类SingletonInstance不会进行装载，只有在使用到的时候才会装载，实现懒加载的效果。

② 当调用getInstance()方法的时候，装载静态内部类SingletonInstance，jvm在装载类的时候是线程安全的，所以没有线程安全的问题

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

5 枚举

代码演示：

public class SingletonTest {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.INSTANCE;
        Singleton singleton2 = Singleton.INSTANCE;
        System.out.println(singleton1 == singleton2); // true
        System.out.println(singleton1.hashCode());
        System.out.println(singleton2.hashCode());
    }
}

enum Singleton {
    INSTANCE;
    public void hello() {
        System.out.println("Hello World!");
    }
}

分析：借助枚举来实现单例，不仅避免多线程同步问题，而且还能防止发序列化重新创建新的对象。推荐使用。同时该方式也是Effective Java作者Josh Bloch提倡的方式。

6 总结

单例模式共八种方式：饿汉式（两种）、懒汉式（四种，包含DoubleCheck）、静态内部类、枚举

推荐使用：枚举、静态内部类、DoubleCheck、饿汉式

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