设计模式之——单例模式

最新推荐文章于 2024-10-04 08:38:41 发布

binbinqq86

最新推荐文章于 2024-10-04 08:38:41 发布

阅读量379

点赞数

分类专栏：设计模式文章标签：设计模式对象应用图片单例模式

本文链接：https://blog.csdn.net/binbinqq86/article/details/74838982

版权

设计模式专栏收录该内容

6 篇文章 0 订阅

订阅专栏

转载请注明出处：http://blog.csdn.net/binbinqq86/article/details/74838982

说起单例模式，相信大多数人都不陌生，甚至都应该用过。没错，它是很多初级工程师唯一会使用的设计模式，也是应用最广泛的模式之一。在应用这个模式时，单例对象的类必须保证只有一个实例存在。很多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体行为。比如最常用的图片加载类ImageLoader，应该只有一个实例，因为它里面包含了很多东西，线程池，缓存系统网络请求等，很消耗资源，因此，没有理由让它构造很多个实例，这种不能自由构造对象的情况，就是单例模式的使用场景。

定义说完了，下面就来简单看看常见单例模式的实现以及分析：

package com.example.tb.designpatten.singleton;

/**
 * Created by TianBin on 2017/7/8 17:45.
 * Description :饿汉模式
 */

public class Sa {
    private static final Sa instance=new Sa();

    private Sa(){}

    public static Sa getInstance(){
        return instance;
    }
}

首先上场的是饿汉模式，这种方式在类初始化的时候就会创建一个实例对象，后期需要的时候就会直接返回该对象，不再去创建新的实例，而且是线程安全的，缺点就是在程序启动的时候就会创建，如果没有用到，会造成资源的浪费。

package com.example.tb.designpatten.singleton;

/**
 * Created by TianBin on 2017/7/8 17:47.
 * Description :懒汉模式
 */

public class Sb {
    private static Sb instance;

    private Sb(){}

    public static synchronized Sb getInstance(){
        if(instance==null){
            instance=new Sb();
        }
        return instance;
    }
}

第二个要将的就是懒汉模式，“懒”字说明了该方式会延迟加载，也就是在获取实例的时候才会去初始化，这样就避免了上面那种情况，但是需要加synchronized关键字去保证线程的安全，这样每次调用都会去进行同步，消耗不必要的资源，这也是懒汉模式存在的最大问题。

package com.example.tb.designpatten.singleton;

/**
 * Created by TianBin on 2017/7/8 17:48.
 * Description :Double Check Lock()DCL
 */

public class Sc {
    private static Sc instance=null;

    private Sc(){}

    public static Sc getInstance(){
        if(instance==null){
            synchronized (Sc.class){
                if(instance==null){
                    instance=new Sc();
                }
            }
        }
        return instance;
    }
}

第三个是DCL实现方式，它的优点是既能在需要的时候才初始化单例，又能保证线程安全，且单例对象初始化后调用getInstance不进行同步锁。它的亮点就在于对instance的两层判断：第一层判断主要是为了避免不必要的同步，第二层判断则是为了在null的情况下创建实例。
DCL优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。缺点：第一次加载反应稍慢，也由于Java内存模型的原因偶尔失败。在高并发环境下也有一定的缺陷，虽然发生概率小。DCL模式是使用最多的单例实现方式，它能够在需要时才实例化单例对象，并且能够在大多数场景下保证单例对象的唯一性。

package com.example.tb.designpatten.singleton;

/**
 * Created by TianBin on 2017/7/8 17:50.
 * Description :静态内部类
 */

public class Sd {
    private Sd(){}

    public static Sd getInstance(){
        return SingletonHolder.instance;
    }

    /**
     * 静态内部类
     */
    private static class SingletonHolder{
        private static final Sd instance=new Sd();
    }
}

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

package com.example.tb.designpatten.singleton;

/**
 * Created by TianBin on 2017/7/8 17:52.
 * Description :枚举
 */

public enum Se {
    INSTANCE;
    public void doSomething(){
        //...
    }
}

第五种是比较罕见的枚举方式实现单例模式。写法简单是它最大的优点。枚举在Java中与普通的类是不一样的，不仅能够有字段，还能够有自己的方法，最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。

package com.example.tb.designpatten.singleton;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by TianBin on 2017/7/8 17:54.
 * Description :容器实现
 */

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

    private Sf(){}

    public static void registerService(String key,Object instance){
        if(!map.containsKey(key)){
            map.put(key,instance);
        }
    }

    public static Object getService(String key){
        return map.get(key);
    }
}

最后一种是用容器来实现单例模式，是不是也比较另类？！在程序的初始，将多种单例类型注入到一个统一管理类中，在使用时根据key获取对象对应的类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

单例模式是运用频率很高的模式，最后总结如下：

优点：

由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建销毁时，而且创建或销毁时性能又无法优化，单例模式的优势非常明显。
由于单例模式只生成一个实例，所以，减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如，可以设计一个单例类，负责所有的数据表的映射处理。