设计模型之创建型模式之单例模式(Singleton)
2016-06-26 23:58
701 查看
定义:保证在一个JVM中,一个对象只有一个实例,并提供一个访问它的全局访问点。
应用:某些对象创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。
优点:省去new操作符,可以降低系统内存的使用频率,减轻GC压力。
比如:有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。
普通单例模式代码:
这个类虽然满足基本要求,但是存在几个问题:
如果该对象被用于序列化,不能保证对象在序列化前后一致
可以通过反射的方式违反单例创建多个对象
毫无线程安全可言,如果我们把它放入多线程的环境下,肯定就会出现问题了
专门用来搞破坏的代码:
为了解决上面问题,代码上做出一些改动。
增加readResolve方法。反序列化时通过反射的方式调用自定义的readResolve方法。
对私有构造器进行对象不为空判断,如果对象不为空,强行创建对象就抛出异常。使反射也不能破坏单例模式。
为工厂方法增加synchronized关键字修饰,使变成线程安全的。
修改后的代码为:
上面虽然解决了一些问题,但是synchronized关键字锁住的是这个对象,这样的用法,在性能上会有所下降,因为每次调用getInstance(),都要对对象上锁,事实上,只有在第一次创建对象的时候需要加锁,之后就不需要了,所以这个地方需要改进。我们改成下面这个:
似乎解决了性能问题,将synchronized关键字加在了内部,也就是说当调用的时候是不需要加锁的,只有在instance为null,并创建对象的时候才需要加锁,性能有一定的提升。但是,这样的情况,还是有可能有问题的。看下面的情况:在Java指令中创建对象和赋值操作是分开进行的,也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序,也就是说有可能JVM会为新的Singleton实例分配空间,然后直接赋值给instance成员,然后再去初始化这个Singleton实例。这样就可能出错了,我们以A、B两个线程为例:
1.A、B线程同时进入了第一个if判断
2.A首先进入synchronized块,由于instance为null,所以它执行instance = new Singleton();
3.由于JVM内部的优化机制,JVM先画出了一些分配给Singleton实例的空白内存,并赋值给instance成员(注意此时JVM没有开始初始化这个实例),然后A离开了synchronized块。
4.B进入synchronized块,由于instance此时不是null,因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
5.此时B线程打算使用Singleton实例,却发现它没有被初始化,于是错误发生了。
所以程序还是有可能发生错误,其实程序在运行过程是很复杂的,从这点我们就可以看出,尤其是在写多线程环境下的程序更有难度,有挑战性。
实际情况是,单例模式使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。
这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式:
其实说它完美,也不一定,如果在构造函数中抛出异常,实例将永远得不到创建,也会出错。所以说,十分完美的东西是没有的,我们只能根据实际情况,选择最适合自己应用场景的实现方法。也有人这样实现:因为我们只需要在创建类的时候进行同步,所以只要将创建和getInstance()分开,单独为创建加synchronized关键字,也是可以的:
通过单例模式的学习告诉我们:
单例模式理解起来简单,但是具体实现起来还是有一定的难度。
synchronized关键字锁定的是对象,在用的时候,一定要在恰当的地方使用(注意需要使用锁的对象和过程,可能有的时候并不是整个对象以及整个过程都需要锁)。
应用:某些对象创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。
优点:省去new操作符,可以降低系统内存的使用频率,减轻GC压力。
比如:有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。
普通单例模式代码:
/* 懒汉式(线程不安全,调用效率不高,可以延迟加载) */ public class Singleton implements Serializable { private static final long serialVersionUID = 1L; /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */ private static Singleton instance = null; /* 私有构造方法,防止被实例化 */ private Singleton() throws Exception { } /* 静态工程方法,创建实例 */ public static Singleton getInstance() throws Exception { if (instance == null) { instance = new Singleton(); } return instance; } }
这个类虽然满足基本要求,但是存在几个问题:
如果该对象被用于序列化,不能保证对象在序列化前后一致
可以通过反射的方式违反单例创建多个对象
毫无线程安全可言,如果我们把它放入多线程的环境下,肯定就会出现问题了
专门用来搞破坏的代码:
public class SerializableDemo { public static void main(String[] args) throws Exception { SerializableDemo sd = new SerializableDemo(); sd.checkObject(); sd.createObject(); } /** * 为了便于理解,忽略关闭流,删除文件操作。真正编码时不要忘记。异常直接抛Exception<br> * 查看序列化前后是否保持一致 */ private void checkObject() throws Exception { // 对象写入文件 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile")); oos.writeObject(Singleton.getInstance()); // 从文件读入对象 File file = new File("tempFile"); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); Singleton newInstance = (Singleton) ois.readObject(); // 判断序列化前后是否保持一致 System.out.println(newInstance == Singleton.getInstance()); } /** * 专门用来破坏单例模型 */ private void createObject() throws Exception { Class<?> onwClass = Class.forName("com.itlwc2.patter.Singleton"); Constructor<?>[] cts = onwClass.getDeclaredConstructors(); cts[0].setAccessible(true); //我多牛逼啊,你是私有我照样用反射可以创建 Singleton newInstance = (Singleton) cts[0].newInstance(); System.out.println(newInstance); } } 打印结果: false com.itlwc2.patter.Singleton@7e425258
为了解决上面问题,代码上做出一些改动。
增加readResolve方法。反序列化时通过反射的方式调用自定义的readResolve方法。
对私有构造器进行对象不为空判断,如果对象不为空,强行创建对象就抛出异常。使反射也不能破坏单例模式。
为工厂方法增加synchronized关键字修饰,使变成线程安全的。
修改后的代码为:
/* 懒汉式(线程安全,可以延迟加载) */ public class Singleton implements Serializable { private static final long serialVersionUID = 1L; /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */ private static Singleton instance = null; /* 私有构造方法,防止被实例化 */ private Singleton() { /* 防止通过以反射的方式违反单例创建多个对象,采取抛出异常的方式 */ if (null != instance) { try { throw new Exception("Can't create another instance"); } catch (Exception e) { e.printStackTrace(); } } } /* 静态工程方法,创建实例 */ public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */ private Object readResolve() { return instance; } }
上面虽然解决了一些问题,但是synchronized关键字锁住的是这个对象,这样的用法,在性能上会有所下降,因为每次调用getInstance(),都要对对象上锁,事实上,只有在第一次创建对象的时候需要加锁,之后就不需要了,所以这个地方需要改进。我们改成下面这个:
/* 静态工程方法,创建实例 */ public static Singleton getInstance() { if (instance == null) { //synchronized不能锁null synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; }
似乎解决了性能问题,将synchronized关键字加在了内部,也就是说当调用的时候是不需要加锁的,只有在instance为null,并创建对象的时候才需要加锁,性能有一定的提升。但是,这样的情况,还是有可能有问题的。看下面的情况:在Java指令中创建对象和赋值操作是分开进行的,也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序,也就是说有可能JVM会为新的Singleton实例分配空间,然后直接赋值给instance成员,然后再去初始化这个Singleton实例。这样就可能出错了,我们以A、B两个线程为例:
1.A、B线程同时进入了第一个if判断
2.A首先进入synchronized块,由于instance为null,所以它执行instance = new Singleton();
3.由于JVM内部的优化机制,JVM先画出了一些分配给Singleton实例的空白内存,并赋值给instance成员(注意此时JVM没有开始初始化这个实例),然后A离开了synchronized块。
4.B进入synchronized块,由于instance此时不是null,因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
5.此时B线程打算使用Singleton实例,却发现它没有被初始化,于是错误发生了。
所以程序还是有可能发生错误,其实程序在运行过程是很复杂的,从这点我们就可以看出,尤其是在写多线程环境下的程序更有难度,有挑战性。
实际情况是,单例模式使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。
这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式:
/* 静态内部类式(线程安全,调用效率高,可以延迟加载)*/ public class Singleton implements Serializable { private static final long serialVersionUID = 1L; /* 私有构造方法,防止被实例化 */ private Singleton() { } /* 单例工厂 */ private static class SingletonFactory { private final static Singleton instance = new Singleton(); } /* 获取单例对象 */ public static Singleton getInstance() { return SingletonFactory.instance; } /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */ public Object readResolve() { return getInstance(); } }
其实说它完美,也不一定,如果在构造函数中抛出异常,实例将永远得不到创建,也会出错。所以说,十分完美的东西是没有的,我们只能根据实际情况,选择最适合自己应用场景的实现方法。也有人这样实现:因为我们只需要在创建类的时候进行同步,所以只要将创建和getInstance()分开,单独为创建加synchronized关键字,也是可以的:
/* 双重锁检测机制,懒汉式(线程安全,可以延迟加载) */ public class Singleton implements Serializable { private static final long serialVersionUID = 1L; /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加 */ private static Singleton instance = null; /* 私有构造方法,防止被实例化 */ private Singleton() { } /* 我是专门设计出来让锁的 */ private static synchronized void syncInit() { if (instance == null) { instance = new Singleton(); } } public static Singleton getInstance() { if (instance == null) { syncInit(); } return instance; } /* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致*/ private Object readResolve() { return instance; } }
通过单例模式的学习告诉我们:
单例模式理解起来简单,但是具体实现起来还是有一定的难度。
synchronized关键字锁定的是对象,在用的时候,一定要在恰当的地方使用(注意需要使用锁的对象和过程,可能有的时候并不是整个对象以及整个过程都需要锁)。
相关文章推荐
- Node.js 工具模块
- Openstack组件部署 — Nova_安装和配置Controller Node
- Ubuntu16.04/LinuxMint18安装openjdk-7-jdk
- 设计模型之创建型模式之抽象工厂模式(Abstract Factory)
- Windows下多线程编程(二)
- Struts2 ModelDriven接口使用
- Calendar类简单常用的几种方法(java核心卷1-D3)
- 设计模型之创建型模式之工厂方法模式(Factory Method)
- UVA 11292[Dragon of Loowater ]
- 引用新浪、Google、微软的CDN加载jQuery
- Java NIO系列教程(十二) Java NIO与IO
- 关于理解重载的深入学习
- 欢迎使用CSDN-markdown编辑器
- FLASK(9)-用户角色
- python解析邮件
- 密码学进展- Crypto16
- RabbitMQ基础知识篇
- day03_Python的函数
- 【hdu】4521 小明系列问题——小明序列【LIS变种】
- java基础(八)Math/代码块/继承成员方法指南的关系/继承中成员变量之间的关系/方法的重写/继承中构造方法之间的关系/this和super的区别