Java设计模式学习---单例模式

Java中单例模式是一种常见的设计模式，单例模式这里主要介绍两种种：懒汉式单例、饿汉式单例。

解决的问题：保证一个类在内存中的对象唯一性。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

Runtime()方法就是单例设计模式进行设计的。

特点：

单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。
不让其他程序创建该类对象----私有化构造函数。

主要优点：

1、提供了对唯一实例的受控访问。

2、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

使用场景：

确认一个类只能有一个对象的场景，避免消耗过多资源。

比如：管理全局的网络请求。图片加载等等。

EventBus的单例采用的是双重检查加锁单例。
Android源码中发现，一个非常重要的类LayoutInflater本身也采用的是单例模式。
在用Fragment时，会应用单例形式提供一个getInstance方法来回去对应的fragment对象。

一、懒汉模式

懒汉模式在第一次调用的时候会初始化自己

public class Singleton {  
    private Singleton() {}  
    private static Singleton single=null;  
    //静态工厂方法   
    public static Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }  
}

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。

（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论。）

以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造。

改造方式一：在getInstance方法上加同步

public static synchronized Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }

改造方式二：双重检查锁定 Double Check Lock (DCL)

第一层判断主要是为了避免不必要的同步，第二层的判断则是为了在null的情况下创建实例。

//volatile 修饰的变量值 不会被本地线程缓存 
private static volatile Singleton instance = null;  //保证instance对象每次都是从主内存中读取最新的值

public static Singleton getInstance() {  
        if (singleton == null) {    
            synchronized (Singleton.class) {    
               if (singleton == null) {    
                  singleton = new Singleton();   //不是原子操作
               }    
            }    
        }    
        return singleton;   
    }

改造方式三：静态内部类（和饿汉模式一个性质）

public class Singleton {    
       
    /**
     * 类级内部类 也就是静态的成员式内部类 该内部类的实例与外部类的实例没有依赖
     * 而且只有被调用的时候才会被装载，从而实现延迟加载
     */
        private static class LazyHolder {    
           private static final Singleton INSTANCE = new Singleton();    
       }    
    private Singleton (){}    
    public static final Singleton getInstance() {    
       return LazyHolder.INSTANCE;    
    }    
}

懒汉模式这三种优化方案特点：

方式一：在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能。
方式二：在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗，volatile 关键字介绍可以参考这里。
方式三：利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有什么性能损耗。

二、饿汉模式

饿汉式单例类.在类初始化时，已经自行实例化。

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    //静态工厂方法   
    public static Singleton1 getInstance() {  
        return single;  
    }  
}

三、两种模式的区别

从以下两点再区分以下这两种方式：

1、线程安全：

饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，
懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。
而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

Java设计模式学习---单例模式

猜你喜欢