Java单例模式的深入了解

一、设计模式概览

1.1、软件设计模式的概念

软件设计模式（software design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。也就是说，它是解决特定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以反复使用。其目的是为了提高代码的可重用性、代码的可读性和代码的可靠性。

1.2、软件设计模式的基本要素

1. 模式名称

 每一个模式都有自己的名字，通常用一两个词来描述，可以根据模式的问题、特点、解决方案、功能和效果来命名。模式名称（patternname）有助于我们理解和记忆该模式，也方便我们来讨论自己的设计。

2. 问题

问题（problem）描述了该模式的应用环境，即何时使用该模式。它解释了设计问题和问题存在的前因后果，以及必须满足的一系列先决条件。

3. 解决方案

模式问题的解决方案（solution）包括设计的组成成分、它们之间的相互关系及各自的职责和协作方式。因为模式就像一个模板，可应用于多种不同场合，所以解决方案并不描述一个特定而具体的设计或实现，而是提供设计问题的抽象描述和怎样用一个具有一般意义的元素组合（类或对象的 组合）来解决这个问题。

4. 效果

描述了模式的应用效果以及使用该模式应该权衡的问题，即模式的优缺点。主要是对时间和空间的衡量，以及该模式对系统的灵活性、扩充性、可移植性的影响，也考虑其实现问题。显式地列出这些效果（consequence）对理解和评价这些模式有很大的帮助。

1.3、gof 的 23 种设计模式的分类和功能

1. 根据目的来分

根据模式是用来完成什么工作来划分，

创建型模式：用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。gof 中提供了单例、原型、工厂方法、抽象工厂、建造者等 5 种创建型模式。

结构型模式：用于描述如何将类或对象按某种布局组成更大的结构，gof 中提供了代理、适配器、桥接、装饰、外观、享元、组合等 7 种结构型模式。

行为型模式：用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。gof 中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。

2. gof的23种设计模式的功能

单例（singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。

原型（prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。

工厂方法（factory method）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。

抽象工厂（abstractfactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。

建造者（builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。

代理（proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。

适配器（adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

桥接（bridge）模式：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

装饰（decorator）模式：动态的给对象增加一些职责，即增加其额外的功能。

外观（facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。

享元（flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。

组合（composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。

模板方法（templatemethod）模式：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

策略（strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。

命令（command）模式：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。

职责链（chain of responsibility）模式：把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。

状态（state）模式：允许一个对象在其内部状态发生改变时改变其行为能力。

观察者（observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。

中介者（mediator）模式：定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。

迭代器（iterator）模式：提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

访问者（visitor）模式：在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。

备忘录（memento）模式：在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。

解释器（interpreter）模式：提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

1.4、软件设计的七大原则

软件设计的七大原则

原则	描述	作用
开闭原则	对扩展开放，对修改关闭	降低维护带来的新风险
依赖倒置原则	高层不应该依赖低层，要面向接口编程	更利于代码结构的升级扩展
单一职责原则	一个类只干一件事，实现类要单一	便于理解，提高代码的可读性
接口隔离原则	一个接口只干一件事，接口要精简单一	功能解耦，高聚合、低耦合
迪米特法则	不该知道的不要知道，一个类应该保持对其它对象最少的了解，降低耦合度	只和朋友交流，不和陌生人说话，减少代码臃肿
里氏替换原则	不要破坏继承体系，子类重写方法功能发生改变，不应该影响父类方法的含义	防止继承泛滥
合成复用原则	尽量使用组合或者聚合关系实现代码复用，少使用继承	降低代码耦合

实际上，这些原则的目的只有一个：降低对象之间的耦合，增加程序的可复用性、可扩展性和可维护性。

记忆口诀：访问加限制，函数要节俭，依赖不允许，动态加接口，父类要抽象，扩展不更改。

在程序设计时，我们应该将程序功能最小化，每个类只干一件事。若有类似功能基础之上添加新功能，则要合理使用继承。对于多方法的调用，要会运用接口，同时合理设置接口功能与数量。最后类与类之间做到低耦合高内聚。

 二、单利模式

1.1、单例模式的相关定义

        指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

单利模式三个特点

单例类只有一个实例对象；

该单例对象必须由单例类自行创建；

单例类对外提供一个访问该单例的全局访问点。  

单例模式的优点

单例模式可以保证内存里只有一个实例，减少了内存的开销。

可以避免对资源的多重占用。

单例模式设置全局访问点，可以优化和共享资源的访问。

单例模式的缺点：

单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。

在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。

单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

单例模式的应用场景

需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 gc。

某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。

某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。

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

频繁访问数据库或文件的对象。

对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套。

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

1.2、单利模式的结构

单例类：包含一个实例且能自行创建这个实例的类。

访问类：使用单例的类。

  

2.1单利模式的实现方式一：懒汉式

该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。

代码：

public class lazysingleton {
 
        //构造器私有,堵死了外界利用new创建此类对象的可能
        private lazysingleton(){
                system.out.println("yese");
 
        }
        //提供对象，是外界获取本类对象的唯一全局访问点
        private static lazysingleton lazysingleton;
 
        public static  lazysingleton getinstance(){
                //如果对象不存在，就new一个新的对象，否则返回已有的对象
                if(lazysingleton == null) {
                        lazysingleton = new lazysingleton();
                }
                return lazysingleton;
        }
}

 @test
    public void testlazy() {
        lazysingleton l1 = lazysingleton.getinstance();
        lazysingleton l2 = lazysingleton.getinstance();
        system.out.println(l1+"\n" + l2);
        system.out.println(l1 == l2);
    }

测试结果：  

com.singletonpattern.lazysingleton@78e03bb5
com.singletonpattern.lazysingleton@78e03bb5
true

 该代码很显然是不适合多线程模式的，这时候就需要给单例模式的对象加上一把锁

class lazysingleton2{
        //构造器私有,堵死了外界利用new创建此类对象的可能
        private lazysingleton2(){
                system.out.println("s2");
 
        }
        //提供对象，是外界获取本类对象的唯一全局访问点
        private static lazysingleton2 lazysingleton2;
 
        public static  lazysingleton2 getinstance(){
                //如果对象不存在，就new一个新的对象，否则返回已有的对象
                if(lazysingleton2 == null) {
                        synchronized(lazysingleton2.class) {
                                if(lazysingleton2 == null) {
                                        lazysingleton2 = new lazysingleton2();
                                }
                        }
                }
                return lazysingleton2;
        }
}

这时还有一个问题，就是在创建一个对象时，在jvm中会经过三步：

（1）为对象分配内存空间

（2）初始化该对象

（3）将该对象指向分配好的内存空间

 那么在执行我们这个多线程代码的过程中，有可能他不按照这三部的顺序走，那么就会导致一个指令重排的问题，解决此问题的方法就是加关键字volatile

class lazysingleton3{
        //构造器私有,堵死了外界利用new创建此类对象的可能
        private lazysingleton3(){
        }
        //提供对象，是外界获取本类对象的唯一全局访问点
        private volatile static lazysingleton3 lazysingleton3;
 
        public static  lazysingleton3 getinstance(){
                //如果对象不存在，就new一个新的对象，否则返回已有的对象
                if(lazysingleton3 == null) {
                        synchronized(lazysingleton3.class) {
                                if(lazysingleton3 == null) {
                                        lazysingleton3 = new lazysingleton3();
                                }
                        }
                }
                return lazysingleton3;
        }
}

最后我们还可以去解决一下反射来破坏单利模式

class lazysingleton4 {
    //提供变量，控制反射
    public static boolean s = false;
 
    //构造器私有,堵死了外界利用new创建此类对象的可能
    private lazysingleton4() {
        if (s == false) {
            //当第一个对象成功获取之后，第二个对象就不能通过反射获取了
            s = true;
        } else {
            throw new runtimeexception("不要用反射破坏异常");
        }
 
    }
 
    //提供对象，是外界获取本类对象的唯一全局访问点
    private volatile static lazysingleton4 lazysingleton4;
 
    public static lazysingleton4 getinstance() {
        //如果对象不存在，就new一个新的对象，否则返回已有的对象
        if (lazysingleton4 == null) {
            synchronized (lazysingleton4.class) {
                if (lazysingleton4 == null) {
                    lazysingleton4 = new lazysingleton4();
                }
            }
        }
        return lazysingleton4;
    }
}

volatile， synchronized这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。

2.2单利模式的实现方式一：饿汉式

该模式的特点是类一旦加载就创建一个单例，保证在调用 getinstance 方法之前单例已经存在了。

代码：

public class hungrysingleton {
    private static final hungrysingleton instance = new hungrysingleton();
    private hungrysingleton() {
    }
    public static hungrysingleton getinstance() {
        return instance;
    }
}

饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容!