当前位置：移动技术网 > IT编程>软件设计>设计模式 > 设计模式--单例

设计模式--单例

2020年03月09日 | 移动技术网IT编程 | 我要评论

概述

单例模式(singletonpattern)，保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式有 3 个特点：

单例类只有一个实例对象；
该单例对象必须由单例类自行创建；
单例类对外提供一个访问该单例的全局访问点；

在很多比较大型的程序中，全局变量经常被用到。如果不用全局变量，那么在使用到的模块中，都需要用参数将全局变量传入，这是非常麻烦的。虽然要减少使用全局变量，但是如果需要，还是要用。单例模式就是对传统的全局的一种改进。单例可以做到延时实例化，即在需要的时候才进行实例化。针对一些大型的类，延时实例化是有好处的。

实现

饿汉式单例

/**
 * 饿汉式单例
 * 线程安全
 */
public class singleton1 {

    // jvm保证在任何线程访问instance静态变量之前一定先创建了此实例
    private static singleton1 instance = new singleton1();

    // 私有化构造方法，保证外界无法直接实例化
    private singleton1() {
    }

    // 提供全局访问点获取唯一的实例
    public static singleton1 getinstance() {
        return instance;
    }
}

优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
场景：这种实现方式适合单例占用内存比较小，在初始化时就会被用到的情况。但是，如果单例占用的内存比较大，或单例只是在某个特定场景下才会用到，使用饿汉模式就不合适了，这时候就需要用到懒汉模式进行延迟加载。

懒汉式单例

/**
 * 双重检查单例(懒汉式)
 * 线程安全
 * 单例实例在第一次使用时进行创建
 */
public class singleton2 {

    private volatile static singleton2 instance = null;

    // 私有化构造函数
    private singleton2() {
    }

    public static singleton2 getinstance() {
        if (instance == null) {
            // 多线程可达，可能存在a实例化释放锁后，阻塞在此的b获得同步锁，所以此处需要双重检测
            synchronized (singleton2.class) {
                if (instance == null) {
                    // 此处的执行顺序期望如下:
                    // 1. memory = allocate() 分配对象的内存空间
                    // 2. ctorinstance() 初始化对象
                    // 3. instance = memory 设置instance指向刚分配的内存
                    // 如果不用volatile修饰变量, 2、3指令可能重排，导致获取未初始化的对象
                    instance = new singleton2();
                }
            }
        }
        return instance;
    }
}

优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁synchronized才能保证单例，(静态同步方法实现的懒汉式)加锁会影响效率。

登记式单例

/**
 * 静态内部类单例(登记式、延迟加载)
 */
public class singleton3 {

    private singleton3() {
    }

    /**
     * 静态内部类
     * 在第一次调用getinstance方法之前，singletonwrapper类是没有被加载的，因为它是一个静态内部类。
     * 当有线程第一次调用getinstance的时候，singletonwrapper就会被class loader加载进jvm，在加载的同时，执行instance的初始化。
     * 所以，这种写法，仍然是一种懒汉式的单例类。
     */
    private static class singletonwrapper {
        private static final singleton3 instance = new singleton3();
    }

    /**
     * 为什么这样写就是线程安全的呢？
     * 因为类的加载的过程是单线程执行的。它的并发安全是由jvm保证的。
     * 所以，这样写的好处是在instance初始化的过程中，由jvm的类加载机制保证了线程安全，
     * 而在初始化完成以后，不管后面多少次调用getinstance方法都不会再遇到锁的问题了。
     *
     * @return
     */
    public static singleton3 getinstance() {
        return singletonwrapper.instance;
    }
}

优点: 内部类只有在外部类被调用才加载，产生singleton实例；又不用加锁。此模式有上述两个模式的优点，屏蔽了它们的缺点，是推荐的单例模式。
缺点: 在实例需要序列化的场景下，反射和序列化会破坏单例，这是懒汉式、饿汉式和登记式共同存在的缺陷。

枚举单例

/**
 * 枚举单例
 * 线程安全
 */
public class singleton4 {

    // 私有构造函数
    private singleton4() {

    }

    public static singleton4 getinstance() {
        return singleton.instance.getinstance();
    }

    // 枚举实例是static final类型的，也就表明只能被实例化一次。
    // 在调用构造方法时，我们的单例被实例化
    private enum singleton {

        instance;

        private singleton4 singleton;

        // jvm保证这个方法绝对只调用一次
        singleton() {
            singleton = new singleton4();
        }

        public singleton4 getinstance() {
            return singleton;
        }
    }
}

枚举提供了序列化机制，推荐的最佳实现方式

反射和反序列化对单例的影响

通过反射来实例化类

/**
 * 用反射来获得实例
 */
public class singleton5 {

    public static void main(string[] args) throws nosuchmethodexception, illegalaccessexception, invocationtargetexception, instantiationexception {
        class<singleton1> clz = singleton1.class;
        constructor<singleton1> constructor = clz.getdeclaredconstructor();
        constructor.setaccessible(true);
        singleton1 reflectinstance = constructor.newinstance();
        singleton1 instance = singleton1.getinstance();
        system.out.println(reflectinstance == instance); // false
    }
}

结果输出false，说明reflectinstance和instance不是同一个对象。(==比较的是实例对象的内存地址)

通过反序列化来实例化类

/**
 * 反序列化来获得实例
 */
public class singleton6 {

    public static void main(string[] args) throws ioexception, classnotfoundexception {

        // 单例(此处对单例进行修改，实现serializable接口)
        singleton1 singleton = singleton1.getinstance();

        // 序列化
        fileoutputstream fos = new fileoutputstream("singleton1.obj");
        objectoutputstream oos = new objectoutputstream(fos);
        oos.writeobject(singleton);
        oos.flush();
        fos.close();
        oos.close();

        // 反序列化
        fileinputstream fis = new fileinputstream("singleton1.obj");
        objectinputstream ois = new objectinputstream(fis);
        singleton1 instance = (singleton1) ois.readobject();
        fis.close();
        ois.close();

        // 对比
        system.out.println(singleton == instance); // false

    }
}

结果输出false，说明singleton和instance指向不同对象。

如何避免单例被破坏

修改单例类，解决反序列化的问题

/**
 * 饿汉式单例
 * 线程安全
 */
public class singleton1 implements serializable {

    // jvm保证在任何线程访问instance静态变量之前一定先创建了此实例
    private static singleton1 instance = new singleton1();

    // 私有化构造方法，保证外界无法直接实例化
    private singleton1() {
    }

    // 提供全局访问点获取唯一的实例
    public static singleton1 getinstance() {
        return instance;
    }

    //该方法在反序列化时会被调用，该方法不是接口定义的方法，有点儿约定俗成的感觉
    protected object readresolve() throws objectstreamexception {
        system.out.println("调用了readresolve方法！");
        return instance;
    }
}

结果输出

调用了readresolve方法！
true

应用场景

单例模式可以避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间。有以下场景的特点即可使用单例。

当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如数据库的连接池、zk分布式锁、工具类等。

当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。

公众号【当我遇上你】

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

设计模式-10-适配器模式-[组合模式]

1.[组合模式] 是 [对象的适配器模式] 的衍生模式组合模式：它在我们树型结构的问题中，模糊了简单元素和... [阅读全文]
软件设计七大原则

软件设计七大原则 1、开闭原则定义：一个软件实体，如类、模块和函数应该对扩展开放，对修改关闭。中心思想：用抽象构建框架，用实现扩展细节。即面向抽象编... [阅读全文]
PHP设计模式—外观模式

定义：外观模式（Facade）：又叫门面模式，为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。 ... [阅读全文]
PHP设计模式—组合模式

定义：组合模式（Composite）：将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。当你发... [阅读全文]
PHP设计模式—装饰器模式

定义：装饰器模式（Decorator）：动态的给一个对象添加一些额外的职责，就增加功能来说，装饰器比生成子类更加灵活。结构： Component：定... [阅读全文]
【设计模式】六大设计原则

六大设计原则单一职责定义每个类都应该有一个单一的功能一个类或者模块应该有且只有一个改变的原因规范定义类的方法避免类之间耦合度太高里氏替换... [阅读全文]
【设计模式】单例模式

定义确保某个类只有一个实例实现方式饿汉式加载（线程安全）等价于懒汉式加载非线程安全线程安全 1. Double Check 2. 借助La... [阅读全文]
23种设计模式简介

设计模式总结创建型模式创建型模式隐藏了这些类的实例是如何被创建和放在一起，整个系统关于这些对象所知道的是抽象类所定义的接口。这样，创建型模式在创建了... [阅读全文]
大话编程之-设计模式篇(简介)

设计模式简介设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程... [阅读全文]
单例模式学习

单例模式学习 1 饿汉式单例模式还没用就创建了对象，可能会浪费空间 2 懒汉式单例模式无线程锁 java package main.java.com... [阅读全文]

网友评论


验证码：