设计模式第六天之单例模式

这次和大家分享一下设计模式中的单例模式。

说到单例模式，我相信大家都了解，简单说就是某个类在整个程序中只有一个对象。那为什么使用单例模式呢？什么场景使用单例模式呢？

我个人认为，在程序设计中，经过分析，某个类有一个对象已经可以满足要求，如果此时再加上这个类会消耗许多资源（包括内存开销大，创建对象耗时等），这个类就推荐使用单例来实现了。比如：数据库连接及相关操作，图片加载，缓存，线程池等等。使用单例模式也可以更好的实现共享资源。

那如何实现单例模式呢？在这里我和大家分享五种方式。在这五种方式中，都是以一个简单的计算器例子来说明，计算加减乘除的类对象明显在程序中只要有一个就可以了。在这里只是为了介绍这些方式实现。

饿汉模式

/**
 * 饿汉模式实现单例模式
 * 好处：简单
 * 缺点：
 * 当类加载的时候就创建了对象而不管对象时候在使用
 * 造成资源的浪费
 * 当内存不足的时候，回收了静态对象，此时访问也会带来bug
 * @author wangpeiyu
 *
 */
public class Hungry {
    private static Hungry instance= new Hungry();
    
    private Hungry(){
        
    }
    public Hungry getInstance(){
        return instance;
    }
    public int add(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }
    public int mul(int a, int b){
        return a*b;
    }
    public float div(int a,int b)
    {
        return a/b;
    }
}

 

懒汉模式

/**
 * 懒汉实现单例模式
 * 好处：解决了线程安全，也做到了要使用的时候才创建对象
 * 缺点：每次要获取该对象的时候，都要进行线程同步，即使在instance已经赋值了之后
 * 还要进行线程同步，这就造成了不必要的时间浪费和资源浪费
 * @author wangpeiyu
 *
 */
public class Lazy {
    private static Lazy instance=null;
    private  Lazy(){}
    public synchronized static Lazy getInstance(){
        if(instance==null){
            instance = new Lazy();
        }
        return instance;
    }
    public int add(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }
    public int mul(int a, int b){
        return a*b;
    }
    public float div(int a,int b)
    {
        return a/b;
    }
}

 

静态内部类方式

/**
 * 静态内部类实现单例模式
 * 好处：线程安全、也达到了延迟加载、当加载单例类的时候并没有创建对象。
 * 缺点：内存不足，回收静态对象时，在访问会出现bug
 * 无法解决发序列化导致的对象重建
 * @author wangpeiyu
 *
 */
public class StaticInClass {
    
    private StaticInClass(){
        
    }
    public static StaticInClass getInstance()
    {
        return SingletonHolder.instance;
    }
    /**
     * 静态内部类
     * 主要的单例类的holder
     * @author wangpeiyu
     *
     */
    private static final class SingletonHolder{
        private static final StaticInClass instance = new StaticInClass();
    }
    public int add(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }
    public int mul(int a, int b){
        return a*b;
    }
    public float div(int a,int b)
    {
        return a/b;
    }
}

 

双重检查加锁方式

/**
 * 双重检查加锁模式实现单例模式
 * 好处：延迟了加载、线程安全，而且也避免了在instance已经赋值的情况下，多线程还要
 * 同步造成的资源浪费和无意义的等待
 * 缺点：当反序列化时无法避免会重新创建对象的问题
 * @author wangpeiyu
 *
 */
public class DCL {
    private static DCL instance = null;
    private DCL(){}
    public static DCL getInstance(){
        if(instance==null){
            synchronized (DCL.class) {
                if(instance==null)
                {
                    instance = new DCL();
                }
            }
        }
        return instance;
    }
    public int add(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }
    public int mul(int a, int b){
        return a*b;
    }
    public float div(int a,int b)
    {
        return a/b;
    }
}

 

枚举方式

/**
 * 使用枚举实现单例
 * 好处：
 * 1.完全确保整个程序只有一个实例
 * 2.线程安全，因为枚举一旦定义结束，编译器就不允许我们再使用其构造器来创建任何实例了
 * 3.构造函数是private的，即使定义为public，一样为private
 * 4.自由序列化，这样即使在反序列化时也不会重新创建
 * @author wangpeiyu
 *
 */
public enum EnumCaculate {
    instance;
    private EnumCaculate(){
    }
    public int add(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }
    public int mul(int a, int b){
        return a*b;
    }
    public float div(int a,int b)
    {
        return a/b;
    }
}

 

    在这五种实现中，我个人比较推荐枚举实现和双重检查加锁实现。原因在每个类的代码中体现了。