文章目录
一、单例模式概述
(1)单例模式简介
单例模式属于创建型模式,所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)。
- 单例类只能有一个实例。
- 单例类必须自己创建自己的唯一实例。
- 单例类必须给所有其他对象提供这一实例。
比如Hibernate的SessionFactory,它充当数据存储源的代理,并负责创建Session对象。SessionFactory并不是轻量级的,一 般情况下,一个项目通常只需要一个SessionFactory就够,这是就会使用到单例模式。
(2)单例模式优缺点
优点
- 在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理学院首页页面缓存)。
- 避免对资源的多重占用(比如写文件操作)。
缺点
- 没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。
(3)单例模式的实现方式
- 懒汉式,线程不安全
- 懒汉式,线程安全
- 饿汉式
- 双检锁/双重校验锁(DCL,即 double-checked locking)
- 登记式/静态内部类
- 枚举
二、懒汉式
1、线程不安全懒汉式
(1)线程不安全懒汉式示例
创建一个类,私有化该类的构造器,创建一个私有的静态常量,并对外提供一个公有的静态方法
/*线程不安全懒汉式*/
public class Singleton1 {
/*私有化构造器*/
private Singleton1(){}
/*本类内部创建静态常量*/
private static Singleton1 singleton ;
/*提供一个对外的公有的静态方法,当使用到的时候才创建这个实例对象*/
public static Singleton1 getSingleton() {
if (singleton == null) {
singleton = new Singleton1();
}
return singleton;
}
}
main方法类
public class Lhs {
public static void main(String[] args) {
Singleton1 singleton1 = Singleton1.getSingleton();
Singleton1 singleton2 = Singleton1.getSingleton();
/*测试两次获取到的是否为同一个实例*/
System.out.println(singleton1 == singleton2);
System.out.println("singleton1的hashCode = " + singleton1.hashCode());
System.out.println("singleton2的hashCode = " + singleton2.hashCode());
}
}
输出结果
true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196
(2)线程不安全懒汉式分析
优缺点
- 起到了Lazy Loading的效果,但是只能在单线程下使用;
- 如果在多线程下,一个线程进入了if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例,所以在多线程环境下不可使用这种方式;
- 在实际开发中,不要使用这种方式。
2、线程安全懒汉式
(1)线程安全懒汉式示例
创建一个类,私有化该类的构造器,创建一个私有的静态常量,并对外提供一个公有的静态方法,同时需要在这个静态方法上加上线程同步锁,控制线程运行。
/*线程安全懒汉式*/
public class Singleton2 {
/*私有化构造器*/
private Singleton2(){}
/*本类内部创建静态常量*/
private static Singleton2 singleton ;
/*提供一个对外的公有的静态方法,在方法上加入同步锁synchronized*/
public static synchronized Singleton2 getSingleton() {
if (singleton == null) {
singleton = new Singleton1();
}
return singleton;
}
}
main方法类
public class Lhs {
public static void main(String[] args) {
Singleton2 singleton1 = Singleton2.getSingleton();
Singleton2 singleton2 = Singleton2.getSingleton();
/*测试两次获取到的是否为同一个实例*/
System.out.println(singleton1 == singleton2);
System.out.println("singleton1的hashCode = " + singleton1.hashCode());
System.out.println("singleton2的hashCode = " + singleton2.hashCode());
}
}
输出结果一致
true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196
(2)线程安全懒汉式分析
优缺点
- 解决了线程不安全问题;
- 效率太低了,每个线程在想获得类的实例时候,执行getSingleton()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接return就行了,方法进行同步效率太低;
- 在实际开发中,不推荐使用这种方式。
3、同步代码块懒汉式
(1)同步代码块懒汉式示例
创建一个类,私有化该类的构造器,创建一个私有的静态常量,并对外提供一个公有的静态方法,同时需要在这个静态方法上加上线程同步锁,控制线程运行。
/*同步代码块饿汉式*/
public class Singleton3 {
/*私有化构造器*/
private Singleton3(){}
/*本类内部创建静态常量*/
private static Singleton3 singleton ;
/*提供一个对外的公有的静态方法*/
public static Singleton3 getSingleton() {
if (singleton == null) {
/*在创建实例出加上同步锁*/
synchronized(Singleton3.class) {
singleton = new Singleton3();
}
}
return singleton;
}
}
main方法类
public class Lhs {
public static void main(String[] args) {
Singleton3 singleton1 = Singleton3.getSingleton();
Singleton3 singleton2 = Singleton3.getSingleton();
/*测试两次获取到的是否为同一个实例*/
System.out.println(singleton1 == singleton2);
System.out.println("singleton1的hashCode = " + singleton1.hashCode());
System.out.println("singleton2的hashCode = " + singleton2.hashCode());
}
}
输出结果一致
true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196
(2)同步代码块懒汉式分析
优缺点
- 这种方式,改为同步产生实例化的的代码块,但是这种同步并不能起到线程同步的作用,假如一个线程进入了if (singleton == nul)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例,会造成线程不安全的问题;
- 在实际开发中,不能使用这种方式
三、饿汉式
1、静态常量饿汉式
(1)静态常量饿汉式示例
新建一个类,将类的构造器私有化,在该类内部创建该类的实例,并对外提供公共的访问方法以获取该类的实例
/*静态常量饿汉式*/
public class Singleton1 {
/*私有化构造器*/
private Singleton1(){}
/*本类内部创建对象实例*/
private final static Singleton1 singleton = new Singleton1();
/*提供一个对外的公有的静态方法,返回这个实例对象*/
public static Singleton1 getSingleton(){
return singleton;
}
}
再main方法类中获取该类的实例,可以得到,每次获取到的都是同一个实例
public class Ehs {
public static void main(String[] args) {
Singleton1 singleton1 = Singleton1.getSingleton();
Singleton1 singleton2 = Singleton1.getSingleton();
/*测试两次获取到的是否为同一个实例*/
System.out.println(singleton1 == singleton2);
System.out.println("singleton1的hashCode = " + singleton1.hashCode());
System.out.println("singleton2的hashCode = " + singleton2.hashCode());
}
}
输出结果为
true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196
(2)静态常量饿汉式分析
优缺点
- 这种写法比较简单,就是在类装载的时候就完成实例化,避免了线程同步问题;
- 没有加锁,执行效率会提高;
- 在类装载的时候就完成实例化,没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费;
- 这种方式基于classloder机制避免了多线程的同步问题,不过,singleton在类装载时就实例化,在单例模式中大多数都是调用getSingleton方法,但是导致类装载的原因有很多种,因此不能确定有其他的方式( 或者其他的静态方法)导致类装载,这时候初始化singleton就没有达到lazy loading的效果;
- 这种单例模式可用,可能造成内存浪费。
2、静态代码块饿汉式
(1)静态代码块饿汉式示例
新建一个类,将类的构造器私有化,在该类内部创建一个静态常量,并通过静态代码块的方式才能关键类的实例赋予静态常量,然后 对外提供公共的访问方法以获取该类的实例
/*静态代码块饿汉式*/
public class Singleton2 {
/*私有化构造器*/
private Singleton2(){}
/*本类内部创建静态变量*/
private static Singleton2 singleton;
/*静态代码块中创建类的实例,并赋值给静态变量*/
static {
singleton = new Singleton2();
}
/*提供一个对外的公有的静态方法,返回这个实例对象*/
public static Singleton2 getSingleton(){
return singleton;
}
}
main方法类
public class Ehs {
public static void main(String[] args) {
Singleton2 singleton1 = Singleton2.getSingleton();
Singleton2 singleton2 = Singleton2.getSingleton();
/*测试两次获取到的是否为同一个实例*/
System.out.println(singleton1 == singleton2);
System.out.println("singleton1的hashCode = " + singleton1.hashCode());
System.out.println("singleton2的hashCode = " + singleton2.hashCode());
}
}
输出结果不变
true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196
(2)静态代码块饿汉式分析
优缺点:
- 这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。
- 这种单例模式可用,但是可能造成内存浪费
四、双检锁/双重校验锁(Double Check)
1、双检锁/双重校验锁示例
创建一个类,私有化其构造器,声明一个静态常量,并加入volatile,对外提供一个公共访问方法,加入双重检查锁。
public class Singleton {
/*静态常量*/
private volatile static Singleton singleton;
/*私有化构造器*/
private Singleton (){}
/*共有方法,加入双重检查锁*/
public static Singleton getSingleton() {
/*第一次检查*/
if (singleton == null) {
synchronized (Singleton.class) {
/*第二次检查*/
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
main方法类
public class DoubleChecked {
public static void main(String[] args) {
Singleton singleton1 = Singleton.getSingleton();
Singleton singleton2 = Singleton.getSingleton();
/*测试两次获取到的是否为同一个实例*/
System.out.println(singleton1 == singleton2);
System.out.println("singleton1的hashCode = " + singleton1.hashCode());
System.out.println("singleton2的hashCode = " + singleton2.hashCode());
}
}
输出结果为
true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196
2、双检锁/双重校验锁分析
优缺点
- Double-Check概念是多线程开发中常使用到的,如代码中所示,我们进行了两次if (singleton == null)检查,这样就可以保证线程安全了。这样,实例化代码只用执行一次,后面再次访问时,判断if (singleton == null),直接return实例化对象,也避免的反复进行方法同步;
- 线程安全,延迟加载,效率较高;
- 在实际开发中,推荐使用这种单例设计模式。
五、登记式/静态内部类
1、登记式/静态内部类示例
创建一个类,私有化其构造器,在该类中设置一个静态内部类并提供一个静态属性,然后对外需要提供一个公共的访问方法
public class Singleton {
/*私有化构造器*/
private Singleton (){}
/*静态内部类,该类中有一个静态属性Singleton*/
private static class SingletonHolder {
private static final Singleton SINGLETON = new Singleton();
}
/*公共访问方法,直接返回SINGLETON*/
public static final Singleton getSingleton() {
return SingletonHolder.SINGLETON;
}
}
main方法类
public class Jtlbl {
public static void main(String[] args) {
Singleton singleton1 = Singleton.getSingleton();
Singleton singleton2 = Singleton.getSingleton();
/*测试两次获取到的是否为同一个实例*/
System.out.println(singleton1 == singleton2);
System.out.println("singleton1的hashCode = " + singleton1.hashCode());
System.out.println("singleton2的hashCode = " + singleton2.hashCode());
}
}
输出结果为
true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196
2、登记式/静态内部类分析
优缺点
- 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
- 静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getSingleton方法, 才会装载SingletonHolder类,从而完成Singleton的实例化。
- 类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
- 避免了线程不安全,利用静态内部类特点实现延迟加载,效率高
- 一般推荐使用该方法
六、枚举
1、枚举示例
创建一个枚举类
public enum Singleton {
INSTANCE; //属性
public void enumMethod() {
System.out.println("枚举式单例模式");
}
}
main方法类
public class MJ {
public static void main(String[] args) {
Singleton singleton1 = Singleton.INSTANCE;
Singleton singleton2 = Singleton.INSTANCE;
/*测试两次获取到的是否为同一个实例*/
System.out.println(singleton1 == singleton2);
System.out.println("singleton1的hashCode = " + singleton1.hashCode());
System.out.println("singleton2的hashCode = " + singleton2.hashCode());
singleton1.enumMethod();
singleton2.enumMethod();
}
}
输出结果为
true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196
枚举式单例模式
枚举式单例模式
2、枚举分析
优缺点
- 这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象;
- 这种方式是Effective Java作者Josh Bloch提倡的方式,一般推荐使用。
七、单例模式使用注意事项
- 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能;
- 当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new;
- 单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂 等);