为什么需要单例模式?
保证类的实例在全局只有一个,避免无效对象创建和销毁时的资源消耗。
在Java中一切都是对象,实例方法的调用需要通过对象,为了调用类中的方法而创建对象,方法调用完成之后对象也需要被GC回收,资源消耗较大。
单例模式有多种实现方式
饿汉式
程序启动即创建单例对象,系统运行中减少对象的创建时间,程序启动较慢,运行过程中响应较快,如果程序整个生命周期中没有用到该单例对象会造成资源的浪费(创建对象和销毁对象)。
java
public class Singleton1 {
private Singleton1(){}
// 饿汉式,程序启动时创建对象,启动耗时,如果对象在整个声明周期内没有使用那么对象创建及销毁浪费时间
private static Singleton1 instance = new Singleton1();
public static Singleton1 getInstance() {
return instance;
}
}
懒汉式
程序启动时不创建对象,在运行的过程中第一次使用时才创建对象,程序启动较快。
同步方法
所有的并发操作都会进行阻塞,效率较低
java
public class Singleton2 {
private Singleton2(){}
private static Singleton2 instance = null;
public static synchronized Singleton2 getInstance(){
if (instance == null) {
instance = new Singleton2();
}
return instance;
}
}
DCL
将同步方法修改为同步代码块,为了保证性能和功能需要使用双重锁判断(Double Check Lock)
需要将单例引用使用 volatile 修饰
java
public class Singleton3 {
private Singleton3(){}
// DCL 方式需要使用volatile进行修饰
private volatile static Singleton3 instance = null;
public static Singleton3 getInstance(){
// DCL(Double Check Lock) 双重锁检查,保证单例的正确和性能
if (instance == null) { // 保证性能,只有第一次并发的线程才会进入代码块内部
synchronized (Singleton3.class){
if (instance == null) { // 保证正确,第一次并发进来的线程也会进行判断
instance = new Singleton3();
}
}
}
return instance;
}
}
静态内部类
静态内部类在单例类中声明一个持有单例对象的内部类,在获取单例对象时从静态内部类中获取持有的单例对象,方法需要使用 final 修饰。
java
public class Singleton4 implements Serializable {
private Singleton4(){}
private static Singleton4 instance = null;
private static class SingletonHolder{
private static Singleton4 instance = new Singleton4();
}
public static final Singleton4 getInstance() {
return SingletonHolder.instance;
}
}
以上四种方式都是
1:将单例类的构造函数私有化,
2:在类内部创建对象,
3:通过方法暴漏给用户
如果对单例对象进行序列化和反序列化也将得到不同的对象,这个问题可以在单例类内部添加 readResolve方法 解决。
枚举
"单元素枚举类已成为Singleton的最佳方法。"-----《effective java》
java
public enum Singleton5 {
INSTANCE;
int value;
private Singleton5(){
System.out.println("Singleton5 is created ! ");
}
public int getValue(){
return value;
}
public void setValue(int value){
this.value = value;
}
}