[设计模式]单例模式

1.单例模式介绍

单利模式是应用最广的模式之一,也可能是很多初级工程师唯一会使用的设计模式。在应用这个模式时,单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局对象,这样有利于我们协调系统整体的行为。如在一个应用中,应该只有一个ImageLoader实例,这个ImageLoader中又含有线程池、缓存系统、网络请求等,很消耗资源,因此,没有理由让他构造多个实例。

这种不能自由构造对象的情况,就是单利模式的使用场景

2.单例模式的定义

确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

3.单例模式的使用场景

确保某个类有且只有一个对象的场景,避免产生多个对象消耗过多的资源,或者某种类型的对象只应该有且只有一个。

例如,创建一个对象需要消耗的资源过多,如果要访问IO和数据库等资源,这时就要考虑使用单例模式了

4.单例模式UML类图

[设计模式]单例模式_第1张图片

角色介绍:
(1)Client——-高层客户端;
(2)Singleton——单例类

实现单例模式有如下几个关键点:
(1)构造函数不对外开放,一般为Private;
(2)通过一个静态方法或者枚举返回单例类对象
(3)确保单例类的对象有且只有一个,尤其是在多线程环境下;
(4)确保单例类对象在反序列化时不会重新构建对象。

通过将单例类的构造函数私有化,使得客户端代码不能通过new的形式手动构造单例类的对象。单例类会暴露一个共有静态方法,客户端需要调用这个静态方法获取到单例类的唯一对象,在或许这个单例对象的过程中需要确保线程安全,及在多线程环境下构造单例类的对象也是有且只有一个,这也是单例模式实现中比较困难的地方。

5.单例模式的简单示例

public class Staff{
    public void work(){
        //干活
    }
}

public class VP extends Staff{
    @Overrride
    public void work{
        //管下面的经理
    }
}

public static class CEO extends Staff{
    private static final CEO mCeo = new CEO;
    //构造函数
    private CEO(){
    }
    //公用的静态函数,对外暴露获取单例对象的接口
    public static CEO getCEO(){
        return mCeo;
    }
    @Override
    public void work(){
        //管理VP
    }
}

public class Company{
    private List<Staff> allStaffs = new ArrayList<Staff>();
    public void addStaff(Staff per){
        allStaffs.add(per);
    }
    public void showAllStaffs(){
        for(Staff per : allStaffs){
            System.out.println("Obj"+per.toString());
        }
    }
}

public class Test{
    public static void main(String[] args){
        Company cp = new Company();

        Staff ceo1 = CEO.getCEO();
        Staff ceo2 = CEO.getCEO();

        cp.addStaff(ceo1);
        cp.addStaff(ceo2);

        Staff vp1 = new VP();
        Staff vp2 = new VP();

        Staff staff1 = new Staff();
        Staff staff2 = new Staff();
        Staff staff3 = new Staff();

        cp.addStaff(vp1);
        cp.addStaff(vp2);
        cp.addStaff(staff1);
        cp.addStaff(staff2);
        cp.addStaff(staff3);

        cp.showAllStaffs();



    }
}

输出结果可以看到CEO类不能通过new的形式构造对象,只能通过CEO.getCEO()函数来获取,而这个CEO对象是静态对象,并且在生命的时候就已经初始化,这就保证了CEO对象的唯一性。从输出结果中发现,CEO两次输出的CEO对象都是一样的,而VP,Staff等类型的都是不同的,这个实现的核心在于将CEO累的构造方法私有化,使得外部程序不能通过构造函数来构造CEO对象,而CEO类通过一个静态方法返回一个静态对象。

6.单例模式的其他实现方式

6.1 懒汉模式

懒汉模式是声明一个静态对象,并且在用户第一次调用getInstance时进行初始化,而上述的饿汉模式(CEO类)是在声明静态对象时已经初始化。

懒汉单例模式实现如下:

public class Singleton{
    private static Singleton instance;
    private Singleton(){}

    public static synchronized Sigleton getInstance(){

        if(instance == null){
            instance = new Singleton();
        }

        return instance;
    }
}

getInstance()加了一个synchronized关键字,也就是说getInstance()是一个同步方法,这就是上面所说的在多线程情况下保证单例对象唯一性的手段。

这时就有问题了,即使instance已经被初始化(第一次调用时就会被初始化instance),每次调用getInstance都会进行同步,这样会消耗不必要的资源,这也就是懒汉单例模式的问题。

最后总结一下,懒汉单例模式的优点是单里只有在使用时才会被实例化,在一定程度上节约资源。
缺点是第一次加载时需要及时进行实例化,反应稍慢,最大的问题是每次调用getInstance都进行同步,造成不必要的同步开销。

这种模式一般不是很建议使用。

6.2 Double CheckLock(DCL)实现单例

DCL方式实现单例模式的优点是既能够在需要时才初始化单例模式,又能保证线程安全,且单例对象初始化后调用getInstance不进行同步锁。

代码如下所示:

public class Singleton{
    private static Singleton sInstance = null;
    private Singleton(){
    }
    public void doSometing(){
        System.out.println("do sth.");
    }
    public static Singleton getInstance(){
        if(mInstahce == null){
            synchronized(Singleton.class){
                if(mInstance == null){
                    sInstance = new Singleton();
                }
            }
        }
        return sInstance;
    }
}

本程序的亮点自然都在getInstance方法上,可以看到getInstance方法对instance进行了两次判断:第一层判断主要是为了避免不必要的同步,第二层判断则是为了在null的情况下创建实例,这是什么意思呢?

首先我们要知道sInstance = new Singleton()这个语句,它大致做了三件事情:
(1)给Singleton的实例分配内存;
(2)调用Singleton()的构造函数,初始化成员字段;
(3)将sInstance对象指向分配的内存空间(此时sInstance就不是null了)。

在JDK1.5之前的JMM长Cache、寄存器到主内存回写顺序的规定,上面的第二和第三顺序是无法保证的,也就是说,执行顺序可能是1-2-3也可能是1-3-2。如果是后者,并且在3执行完毕,2未执行之前,被切换到线程B上,这时候sInstance因为已经在线程A内执行过了第三点,sInstance已经是非空了,所以,线程B直接取走sInstance,再使用时就会出错,这就是DCL失效的问题,而且这种难以跟踪。

JDK1.5之后SUN公司调整了JMM,具体化了volatile关键字,因此,只需要将sInstance的定义改成private volatile static Singleton sInstance = null就可以保证sInstance对象每次都是从主内存中读取,就可以使用DCL的写法来完成单例模式,当然使用volatile或多或少也会影响到性能。

DCL的有点:资源利用率高,第一次执行getInstance是时单例对象才会被实例化,效率高。
缺点:第一次加载时反应有点慢,也由于java的内存模型的原因偶尔会失败,在高并发环境下也有一定的缺陷,虽然发生的概率很小。DCL模式是使用最多的单例实现方式,它能够在需要时才实例化单例对象,并且能够在绝大多数场景下保证单例对象的唯一性。除非代码在并发场景比较复杂。

6.3 静态内部类单例模式

DCL虽然在一定程度上解决了资源消耗、多余的同步、线程安全等问题但是,他还是在某下情况下出现时效的问题,这个问题被称为双重检查锁定失效,在《java并发编程实践》这一书中有讨论。
建议使用如下代码进行替换

public class Singleton{
    private Singleton(){}
    public static Singleton getInstance(){
        return SingletonHolder.sInstance;
    }
    //静态内部类
    private static class SingletonHolder{
        private static final Singleton sInstance = new Singleton();
    }
}

当第一次加载Singleton类时并不会初始化sInstance,只有在第一次调用Singleton的getInstance方法时才会导致sInstance被初始化。因此,第一次调用getInstance方法会导致虚拟机加载SingletonHolder类,这种方式不仅能够保证线程安全,也能够保证单例对象的唯一性,同事也延迟了单例的实例化,所以这是推荐使用单例模式的实现方式。

6.4 枚举单例

枚举就是最简单的单例实现方法

public enum SingleEnum{
    INSTANCE;
    public void doSomething{
        System.out.println("do sth.");
    }
}

写法简单就是枚举最大的优点,枚举在Java中与普通的类是一样的,不仅能够有字段,还能够有自己的方法。更重要的是默认枚举实例的创建是线程安全的,并且在任何情况下它都是一个单例。

6.5使用容器实现单例模式

public class SingletonManager{
    private static Map<String,Object> objMap = new HashMap<String,Object>();

    private Singleton(){}
    public static void registerService(String key,Object instance){
        if (!objMap.containKey(key)) {
            objMap.put(key,instance);

        }
    }
    public static ObjectgetService(String key){
        return objMap.get(key);
    }
}

这种形式可以将多种单例类型注入到一个统一的管理类中,在使用时根据key获取对应类型的对象。这种方式使得我们可以管理多种类型的单例,并且在使用时可以通过统一的接口进行获取操作,降低了用户的使用成本也对用户隐藏了具体实现,降低了耦合度。

总而言之,不管以那种形式实现单例模式,他的核心原理都是将构造函数私有化,并且通过静态方法获取一个唯一的实例,在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题。

你可能感兴趣的:(设计模式)