单例模式(Singletion Pattern)是Java中最简单的设计模式质疑.这种类型的实际模式属于创建型模式,它提供了一种创建对象的最佳方式.
这种模式设计到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建.这个类也要提供一种访问其唯一对象的方式,可以直接访问,不需要实例化该类的对象.
1.1 单例模式的结构
单例模式主要有以下角色
- 单例类.只能创建一个实例对象的类
- 访问类.使用单例类
1.2 单例模式的实现
饿汉式: 类加载就会导致该单实例对象被创建 懒汉式: 类加载不会导致该单实例对象被创建,而是首次使用该对象时才会被创建
- 饿汉式-方式1 (静态变量式)
/**
* 饿汉式
* 静态变量创建类的对象
*/
pubilc class Singleton{
//私有化构造方法
private Singleton(){};
//在成员位置创建该类的对象
private static Singletion instance = new Singleton();
//对外提供静态方法获取该对象
public static Singleton getInstance(){
return instance;
}
}
说明:
该方法在成员位置生命Singleton类型的静态变量,并创建了Singleton类对象instance.instance对象是随着类的加载而创建的.如果该对象足够大的话,并且一直没有使用就会造成内存的浪费.
1.饿汉式-方法2(静态代码块方式)
/**
* 饿汉式
* 在静态代码块中创建该类对象
*/
public class Singleton{
//私有化构造方法
private Singleton(){};
//在成员位置创建该类的对象
private static Singleton instance;
static {
instance = new Singleton();
}
//对外提供静态方法获取该对象
public static Singleton getInstance(){
return instance;
}
}
说明:
该方式在成员位置生命了Singleton类型的静态变量,而对象的创建实在静态代码块中,也是随着类的加载而加载,所以和饿汉式的方法1基本上一样,该方法也存在这内存浪费问题.
2.懒汉式-方式1（线程不安全）
/**
* 懒汉式
* 线程不安全
*/
public class Singleton{
//私有化构造方法
private Singleton(){};
//在成员位置拆功能键该类的对象
private static Singleton instance;
//对外提供静态方法获取该对象
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
说明：
从上面代码我们可以看出该方法在成员位置生命Singleton类型的静态变量,并没有进行对象的赋值操作,
只有当我们调用getInstance()方法获取Singleton类对象的时候才会创建Singleton类的对象,这样就实现了懒加载的效果,但是如果是多线程环境,会出现线程安全的问题.
3.懒汉式-方式2（线程安全）
/**
* 懒汉式
* 线程安全
*/
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance;
//对外提供静态方法获取该对象
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
说明：
该方法也实现了懒加载的效果,同时又解决了线程安全问题.但是在getInstance()方法上添加了synchronized关键字,导致该方法的执行效果特别低.从上面代码我们可以看出,其实就是在初始化instance的时候才会出现线程安全问题.一旦初始化完成就不存在了.是典型的读多写少问题.
4.懒汉式-方式3 (双重检查锁)
再来讨论一下懒汉模式中的加锁问题,对于getInstance()方法来说,绝大部门的操作都是读操作,读操作是线程安全的.所以我们没必要让每一个线程必须持有锁的时候才能调用该方法,我们需要调整加锁的时机,由此也产生了一种新的实现模式.双重检查锁模式
/**
* 双重检查方式
*/
public class Singleton {
//私有构造方法
private Singleton() {}
private static Singleton instance;
//对外提供静态方法获取该对象
public static Singleton getInstance() {
//第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
if(instance == null) {
synchronized (Singleton.class) {
//抢到锁之后再次判断是否为null
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
双重检查锁模式是一种非常好的单例实现模式,解决了单例,性能.线程安全问题,上面的双重检查锁模式看上去完美无缺,其实存在问题.在多线程的情况下.可能会出现空指针问题.出现问题的原因是jvm在实例化对象的时候会进行优化和指令重排序操作.
要解决双重检查锁带来的空指针异常问题,只需要使用volatile关键字,volatile关键字可以保证可见性和有序性
/**
* 双重检查方式
*/
public class Singleton {
//私有构造方法
private Singleton() {}
private static volatile Singleton instance;
//对外提供静态方法获取该对象
public static Singleton getInstance() {
//第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实际
if(instance == null) {
synchronized (Singleton.class) {
//抢到锁之后再次判断是否为空
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
小结：
添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。
5.枚举类
枚举类实现单例模式是极力推荐的单例实现模式,应为枚举类型是线程安全的,并且只会装载一次,设计者充分利用了枚举的这个特性来实现单例模式,枚举的写法非常简单,而且枚举类型是所有单例实现中唯一一种不会被破坏的单例实现模式
/**
* 枚举方式
*/
public enum Singleton {
INSTANCE;
}
说明：
枚举方式属于恶汉式方式。
1.3 存在的问题
1.3.1 问题演示
破坏单例模式：
使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。
-
序列化反序列化
Singleton类：
public class Singleton implements Serializable { //私有构造方法 private Singleton() {} private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } //对外提供静态方法获取该对象 public static Singleton getInstance() { return SingletonHolder.INSTANCE; } }Test类：
public class Test { public static void main(String[] args) throws Exception { //往文件中写对象 //writeObject2File(); //从文件中读取对象 Singleton s1 = readObjectFromFile(); Singleton s2 = readObjectFromFile(); //判断两个反序列化后的对象是否是同一个对象 System.out.println(s1 == s2); } private static Singleton readObjectFromFile() throws Exception { //创建对象输入流对象 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt")); //第一个读取Singleton对象 Singleton instance = (Singleton) ois.readObject(); return instance; } public static void writeObject2File() throws Exception { //获取Singleton类的对象 Singleton instance = Singleton.getInstance(); //创建对象输出流 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt")); //将instance对象写出到文件中 oos.writeObject(instance); } }上面代码运行结果是
false，表明序列化和反序列化已经破坏了单例设计模式。 -
反射
Singleton类：
public class Singleton { //私有构造方法 private Singleton() {} private static volatile Singleton instance; //对外提供静态方法获取该对象 public static Singleton getInstance() { if(instance != null) { return instance; } synchronized (Singleton.class) { if(instance != null) { return instance; } instance = new Singleton(); return instance; } } }Test类：
public class Test { public static void main(String[] args) throws Exception { //获取Singleton类的字节码对象 Class clazz = Singleton.class; //获取Singleton类的私有无参构造方法对象 Constructor constructor = clazz.getDeclaredConstructor(); //取消访问检查 constructor.setAccessible(true); //创建Singleton类的对象s1 Singleton s1 = (Singleton) constructor.newInstance(); //创建Singleton类的对象s2 Singleton s2 = (Singleton) constructor.newInstance(); //判断通过反射创建的两个Singleton对象是否是同一个对象 System.out.println(s1 == s2); } }上面代码运行结果是
false，表明序列化和反序列化已经破坏了单例设计模式
注意：枚举方式不会出现这两个问题。
1.3.2 问题的解决
-
序列化、反序列方式破坏单例模式的解决方法
在Singleton类中添加
readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。Singleton类：
public class Singleton implements Serializable { //私有构造方法 private Singleton() {} private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } //对外提供静态方法获取该对象 public static Singleton getInstance() { return SingletonHolder.INSTANCE; } /** * 下面是为了解决序列化反序列化破解单例模式 */ private Object readResolve() { return SingletonHolder.INSTANCE; } }源码解析：
ObjectInputStream类
public final Object readObject() throws IOException, ClassNotFoundException{ ... // if nested read, passHandle contains handle of enclosing object int outerHandle = passHandle; try { Object obj = readObject0(false);//重点查看readObject0方法 ..... } private Object readObject0(boolean unshared) throws IOException { ... try { switch (tc) { ... case TC_OBJECT: return checkResolve(readOrdinaryObject(unshared));//重点查看readOrdinaryObject方法 ... } } finally { depth--; bin.setBlockDataMode(oldMode); } } private Object readOrdinaryObject(boolean unshared) throws IOException { ... //isInstantiable 返回true，执行 desc.newInstance()，通过反射创建新的单例类， obj = desc.isInstantiable() ? desc.newInstance() : null; ... // 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为true if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) { // 通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量 // 这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。 Object rep = desc.invokeReadResolve(obj); ... } return obj; } -
反射方式破解单例的解决方法
public class Singleton { //私有构造方法 private Singleton() { /* 反射破解单例模式需要添加的代码 */ if(instance != null) { throw new RuntimeException(); } } private static volatile Singleton instance; //对外提供静态方法获取该对象 public static Singleton getInstance() { if(instance != null) { return instance; } synchronized (Singleton.class) { if(instance != null) { return instance; } instance = new Singleton(); return instance; } } }说明:
这种方式比较好理解。当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。
扫一扫
495
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
