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工厂等)。