前言
作为一个好学习的程序开发者,应该会去学习优秀的开源框架,当然学习的过程中不免会去阅读源码,这也是一个优秀程序员的必备素养,在学习的过程中很多人会遇到的障碍,那就是设计模式。很多优秀的框架会运用设计模式来达到事半功倍的效果。鉴于自己之前对设计模式的生疏,在阅读源码时遇到设计模式的巧妙运用理解比较吃力。最近搞了一本新书 《图解设计模式》(目测讲的很基础)开始学习设计模式,对今后学习源码打下坚实的基础。后续我在阅读本书的过程中,我将记录下自己学习总结。今天就从最常使用的单例模式说起。
单例模式
在许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。(维基百科)。
懒汉式
在单例模式中,有一种称为懒汉式的单例模式。顾名思义,懒汉式可以理解使用时才进行初始化,它包括私有的构造方法,私有的全局静态变量,公有的静态方法,是一种懒加载机制。
public class Singleton {
private static Singleton instance;
private Singleton() {
System.out.println("初始化");
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
上面是最常见的懒汉式单例模式的写法,但是如果在多线程的情况下,上述方法就会出现问题,它达不到只有一个单例对象的效果,例如当某个线程1调用getInstance()方法并判断instance == null
,此时(就在判断为空后new Singleton()之前)另一个线程2也调用getInstance()方法,由于此时线程1还没有new出对象,则线程2执行getInstance()中instance 也为空,那么此时就会出现多个实例的情况,而达不到只有一个实例的目的。
懒汉式(线程安全)
在上述实现中我们提到的懒汉式单例模式是一种非线程安全的,非线程安全即多线程访问时会生成多个实例。那么怎么样实现线程安全呢,也许你应该已经想到使用同步关键字synchronized。
public class Singleton {
private static Singleton instance;
private Singleton() {
System.out.println("初始化");
}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
使用同步关键字后,也就实现了线程安全访问,因为在任何时候它只能有一个线程调用 getInstance() 方法。那么你可能会发出疑问,这样加入同步,在高并发情况下,效率是很低的,因为真正需要同步的是我们第一次初始化的时候,是的,所以我们要进行进一步的优化。
双重检测机制
双重检测顾名思义就是两次检测,一次是检测instance 实例是否为空,进行第一次过滤,在同步快中进行第二次检测,因为当多个线程执行第一次检测通过后会同时进入同步快,那么此时就有必要进行第二次检测来避免生成多个实例。
public class Singleton {
private static Singleton instance;
private Singleton() {
System.out.println("初始化");
}
public static Singleton getInstance() {
if(instance==null){
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
对于上面的代码时近乎完美的,既然说近乎完美,那肯定还是有瑕疵的,瑕疵出现的原因就是instance = new Singleton();这一句代码,你可能会问,这会有什么问题,其实我也不知道,哈哈。在计算机语言中,初始化包含了三个步骤
- 分配内存
- 执行构造方法初始化
- 将对象指向分配的内存空间
由于java编译器为了尽可能减少内存操作速度远慢于CPU运行速度所带来的CPU空置的影响,虚拟机会按照自己的一些规则(这规则后面再叙述)将程序编写顺序打乱——即写在后面的代码在时间顺序上可能会先执行,而写在前面的代码会后执行——以尽可能充分地利用CPU就会出现指令重排序(happen-before),从而导致上面的三个步骤执行顺序发生改变。正常情况下是123,但是如果指令重排后执行为1,3,2那么久会导致instance 为空,进而导致程序出现问题。
既然已经知道了上述双重检测机制会出现问题,那么我们该怎么避免出现呢,该如何解决呢,最好的办法就是不要使用,开个玩笑啦。java中有一个关键字volatile,他有一个作用就是防止指令重排序,那么我们把singleton用volatile修饰下就可以了,如下。
private volatile static Singleton singleton;
饿汉式
饿汉式与懒汉式区别是它在类加载的时候就进行初始化操作,而懒汉式是调用getInstance()方法时才进行初始化。
public class Singleton{
private static final Singleton instance = new Singleton();
private Singleton() {
System.out.println("初始化");
}
public static Singleton getInstance(){
return instance;
}
}
与懒汉式相比,它是线程安全的(无需用同步关键字修饰),由于没有加锁,执行效率也相对较高,但是也有一些缺点,在类加载时就初始化,会浪费内存。
静态块实现方式
public class HungrySingleton implements Serializable {
private static HungrySingleton instance = null;
static {
instance = new HungrySingleton();
}
private HungrySingleton() {
System.out.println("初始化");
}
public static HungrySingleton getInstance(){
return instance;
}
}
静态内部类实现方式
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton() {
System.out.println("初始化");
}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
枚举方式
public enum EnumSinglton {
INSTANCE;
private EnumSinglton() {
System.out.println("构造方法");
}
public void doSomething() {
System.out.println("调用单例方法");
}
}
枚举方式实现的单例模式是一种线程安全的单例模式。
序列化对单例模式的影响
通过上面我们对单例模式的学习,对单例模式有了进一步的学习,当我们有序列化的需求之后,那么会产生怎样的效果呢?先通过下面的代码来看下结果
public class Main {
public static void main(String[] args) throws Exception {
//测试序列化对单例模式的影响
ByteArrayOutputStream bos = new ByteArrayOutputStream();
new ObjectOutputStream(bos).writeObject(LazySingleton.getInstance());
ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray());
LazySingleton singleton = (LazySingleton) new ObjectInputStream(bin).readObject();
System.out.println(singleton == LazySingleton.getInstance());//false
System.out.println( EnumSinglton.INSTANCE == EnumSinglton.INSTANCE );//true
}
}
通过我们的测试瞬时就懵逼了,除了通过枚举方式实现的单例模式,其它几种实现都生成了多个实例。那么该如何解决呢?难道反序列话只能生成多个实例。当然不是。我们可以看下面修改后的代码
public class HungrySingleton implements Serializable {
private static HungrySingleton instance = new HungrySingleton();
//饿汉式变种5
static {
instance = new HungrySingleton();
}
private HungrySingleton() {
System.out.println("初始化");
}
public static HungrySingleton getInstance(){
return instance;
}
/**
* 如果序列化,需要加入此方法,否则单例模式无效
* @see java.io.ObjectStreamClass
* @return
*/
private Object readResolve() {
return instance;
}
}
静态内部类相对实现较为简单,并且它是一种懒加载机制, 当Singleton 类被装载了,instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用,只有显示通过调用 getInstance 方法时,才会显示装载 SingletonHolder 类,从而实例化 instance。
好了,关于单例模式到这里已经介绍完毕了。有问题欢迎留言指出,Have a wonderful day .