Java设计模式-单例模式详解(Singleton Pattern)

骑猪看日落 2022-05-25 01:23 251阅读 0赞

**目录**

1、单例模式简介

2、单例模式基本知识

2.1、基本思路

2.2、特征

2.3、主要解决场景及使用场景

2.4、单例模式的优缺点

2.5、单例模式注意点

3、单例模式实现方式详解

3.1、单例模式实现过程示例

3.2、单例模式实现方式

第一种实现方式：懒汉模式，线程不安全

第二种实现方式：懒汉模式，线程安全加锁synchronize

第三种实现方式：恶汉模式

第四种实现方式：双重说锁/双重校验锁(DLC，即double-checked locking)

第五种实现方式：登记式/静态内部类

--------------------

# **1、单例模式简介** #

单例模式(Singleton Pattern)是Java中最常见最简单的设计模式之一。这种设计模式属于五个创建型的一种，他提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象方式，可以直接访问，不需要也不能直接从该类外部进行实例化，即在该类的外部不能直接使用new关键字进行实例化操作，而是通过该类提供的一个public的静态方法进行获取对象的实例。

**注意：**

*  1、单例类只能有一个实例。
 *  2、单例类必须自己创建自己的唯一实例。
 *  3、单例类必须给所有其他对象提供这一实例。

# **2、单例模式基本知识** #

## **2.1、基本思路** ##

一个类能返回对象的一个引用（永远是同一个对象的引用，地址相同）和一个获得该实例的方法（静态方法），当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时还需要将该类的构造方法私有化(使用private修饰)，这样其他处的代码就无法通调用该类的构造函数进行实例化(不能使用new关键字进行实例化)该类的对象，只可以使用该类对外提供的静态方法来获取该类的唯一实例。

实现单利模式的原则和过程：

*  1、单例模式：确保一个类只有一个实例，自行实例化并向系统提供这个实例 
 *  2、单例模式分类：饿单例模式（类加载时实例化一个对象给自己的引用），懒单例模式（调用取得实例的方法如getInstance时才会实例化对象）（java中饿单例模式性能优于懒单例模式，c++中一般使用懒单例模式） 
 *  3、单例模式三要素： a.私有构造方法 、  b.私有静态引用指向自己实例 、 c.以自己实例为返回值的公有静态方法

## **2.2、特征** ##

单例类的构造器私有化，保证一个类有且仅有一个实例，并提供一个访问它的全局访问点，即提供内部实例化的静态方法。

## **2.3、主要解决场景及使用场景** ##

判断系统是否有单例类的实例，若有则返回实例，没有每部实例化；消除一个全局使用的类频繁地创建与销毁，而影响系统的性能；单例模式可以控制实例数目，节省系统资源的时候。

适用场景：   
单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。如：   
    1.需要频繁实例化然后销毁的对象。   
    2.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。   
    3.有状态的工具类对象。   
    4.频繁访问数据库或文件的对象。

## **2.4、单例模式的优缺点** ##

**优点：**

*   *  1、在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例 
     *  2、单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。 
     *  3、提供了对唯一实例的受控访问。 
     *  4、由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。 
     *  5、允许可变数目的实例。 
     *  6、避免对共享资源的多重占用。

**缺点：**

*    1、不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。 
 *    2、由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。 
 *    3、单例类的职责过重，在一定程度上违背了“单一职责原则”。 
 *    4、滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

## **2.5、单例模式注意点** ##

单例模式在多线程情况下，使用必须小心。如果当唯一实例尚未被创建，有两个线程同时调用创建噶单例类的实例时，那么他们同时没有检测到唯一实例的存在，从而同时各自创建一个实例(对于单个线程而言，创建一个实例时符合单例模式特点的)，这就可能会创建两个实例，从而违反了单例模式中实例唯一性的原则。解决这个问题的办法就是为目标类是否已经实例提供一个互斥锁（当然这样会降低效率）。

1、使用时不能用反射模式创建单例，否则会实例化一个新的对象   
 2、使用懒单例模式时注意线程安全问题   
 3、饿单例模式和懒单例模式构造方法都是私有的，因而是不能被继承的，有些单例模式可以被继承（如登记式模式）

# **3、单例模式实现方式详解** #

## **3.1、单例模式实现过程示例** ##

第一步：创建一个Singleton类

/**   
     * Copyright © 2018 GBOYS CSDN Blog Module. All rights reserved.
     *
     * @Package: com.gxboys.pattern.singleton
     */
    package com.gxboys.pattern.singleton;
    
    /**
     * @See: Using GXBOYS Blog In CSDN
     *
     * @ClassName: Singleton
     * @Description: 单例模式(流程测试)
     * @author: GXBOYS
     * @date: 2018年5月5日 下午6:29:31
     */
    public class Singleton {
    
        // 创建单例对象
        private static Singleton instance = new Singleton();
    
        // 私有化构造器,外部无法通过new关键字实例化该对象
        private Singleton() {
        }
    
        // 对外提供一个唯一可以获取对象接口方法
        public static Singleton getInstance() {
            return instance;
        }
    
        // 测试方法
        public void showMessage() {
            System.out.println("欢迎学习单例模式流程.");
        }
    }

第二步：从Singleton外部获取对象(Test类调用)

package com.gxboys.pattern.singleton;
    
    public class Test {
    
        public static void main(String[] args) {
    
            Singleton singleton = null;
    
            // 使用new关键字 编译时会报错,提示：The constructor Singleton() is not visible.
            // singleton = new Singleton();
    
            // 获取唯一可用的对象
            singleton = Singleton.getInstance();
    
            // 显示消息
            singleton.showMessage();
        }
    }

第三步：测试结果

1、使用关键字new获取对象  
![70][]

2、调用方法获取对象

![70 1][]

## **3.2、单例模式实现方式** ##

单例模式实现方式一般分为懒汉模式、饿汉模式

### 第一种实现方式：懒汉模式，线程不安全 ###

*  是否Lazy初始化：**否**
 *  是否多线程安全**：否**
 *  实现难易程度**：容易**
 *  描述：这种方式是最基本最简答的实现方式，但是最大的问题在于不支持多线程实现(即线程不安全)。因为没有设置加锁synchronize，严格意义上该方式不属于单例模式。这种方式lazy loading很明显，不要求线程安全，所以在多线程下是无法正常工作的。

代码实例

/**   
     * Copyright © 2018 GBOYS CSDN Blog Module. All rights reserved.
     *
     * @Package: com.gxboys.pattern.singleton
     */
    package com.gxboys.pattern.singleton;
    
    /**
     * @See: Using GXBOYS Blog In CSDN
     *
     * @ClassName: LazySingleton
     * @Description: 懒汉模式,线程不安全
     * @author: GXBOYS
     * @date: 2018年5月5日 下午7:10:38
     */
    public class LazySingleton {
        // 设置实例变量
        private static LazySingleton instance;
    
        // 私有化构造器
        private LazySingleton() {
        }
    
        // 对外提供获取对象实例接口
        public static LazySingleton getInstance() {
            // 懒汉模式,对象实例存在直接返回,不存在则内部实例化
            if (instance == null) {
                instance = new LazySingleton();
            }
            return instance;
        }
    }

### 第二种实现方式：懒汉模式，线程安全加锁synchronize ###

*  是否Lazy初始化：**是**
 *  是否支持多线程：**是**
 *  实现难易程度：**容易**
 *  描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
 *  优点：第一次调用才初始化，避免内存浪费。
 *  缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。  
    getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

代码实例

/**   
     * Copyright © 2018 GBOYS CSDN Blog Module. All rights reserved.
     *
     * @Package: com.gxboys.pattern.singleton
     */
    package com.gxboys.pattern.singleton;
    
    /**
     * @See: Using GXBOYS Blog In CSDN
     *
     * @ClassName: LazySingleton
     * @Description: 懒汉模式,线程安全
     * @author: GXBOYS
     * @date: 2018年5月5日 下午7:26:35
     */
    public class LazySingleton {
    
        private static LazySingleton instance;
    
        private LazySingleton() {
        }
    
        // 加锁
        public static synchronized LazySingleton getInstance() {
            if (instance == null) {
                instance= new LazySingleton();
            }
            return instance;
        }
    }

### 第三种实现方式：恶汉模式 ###

*      是否Lazy初始化：否
 *      是否支持多线程：是
 *      实现难易程度：容易
 *      描述：这种方式比较常用，没一个线程都会产生一个实例，所以不存在线程安全问题。但正是这种方式，会差生过多的垃圾，增加GC压力。
 *      优点：没有加锁，执行效率会提高。
 *      缺点：类加载时就初始化，浪费内存。

它基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

代码实例

### 第四种实现方式：双重说锁/双重校验锁(DLC，即double-checked locking) ###

*  JDK 版本：JDK1.5 起
 *  是否 Lazy 初始化：是
 *  是否多线程安全：是
 *  实现难度：较复杂
 *  描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

getInstance() 的性能对应用程序很关键。

代码实例

/**   
     * Copyright © 2018 GBOYS CSDN Blog Module. All rights reserved.
     *
     * @Package: com.gxboys.pattern.singleton
     */
    package com.gxboys.pattern.singleton;
    
    /**
     * @See: Using GXBOYS Blog In CSDN
     *
     * @ClassName: DLCSingleton
     * @Description: 双重说锁/双重校验锁模式
     * @author: GXBOYS
     * @date: 2018年5月5日 下午7:53:42
     */
    public class DLCSingleton {
       
        private volatile static DLCSingleton instance;
    
        private DLCSingleton() {
        }
    
        public static DLCSingleton getSingleton() {
            if (instance== null) {
                synchronized (DLCSingleton.class) {
                    if (instance== null) {
                        instance= new DLCSingleton();
                    }
                }
            }
            return instance;
        }
    }

注： DLC模式需要借助关键字volatile，了解这个关键字需要什么研究JVM相关的重排序特性，在这儿暂不作介绍，后续会单独讲解DLC模式。这个同时需要JDK5或更高版本（因为从JDK5开始使用新的JSR-133内存模型规范，这个规范增强了volatile的语义）

### 第五种实现方式：登记式/静态内部类 ###

*  是否 Lazy 初始化：是
 *  是否多线程安全：是
 *  实现难度：一般
 *  描述：这种方式能到达DLC同样的效果，但实现简单对静态域使用延迟初始化，应使用这种方式而非DLC模式。

这种方式只适静态域的情况，DLC方式可以使用于实例域需要加载时使用。该方式同样利用classLoader机制来保证初始化instance时只有一个线程，它跟第三种方式不同的是：第三种只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading的效果），而这种方式是Single类被加载了，instance不一定被初始化。因为SingletonHoller类没有被主动使用，只有通过显示调用getInstance方法时，才会显显式装载SingletonHolder类，从而实例化instance。想象一下如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

代码实例

/**  
     * Copyright © 2018 GBOYS CSDN Blog Module. All rights reserved.
     *
     * @Package: com.gxboys.pattern.singleton
     */
    package com.gxboys.pattern.singleton;
    
    /**
     * @See: Using GXBOYS Blog In CSDN
     *
     * @ClassName: StaticSingleton
     * @Description: TODO
     * @author: 登记式/静态内部类
     * @date: 2018年5月5日 下午9:46:48
     */
    public class StaticSingleton {
    
        private static class SingletonHolder {
            private static final StaticSingleton INSTANCE = new StaticSingleton();
        }
    
        private StaticSingleton() {
        }
    
        public static final StaticSingleton getInstance() {
            return SingletonHolder.INSTANCE;
        }
    }

一般情况下的赘述:不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

\--------------------------------------------------------------------------------------  
作者：超级字节码  
来源：CSDN  
原文：https://blog.csdn.net/dgxin\_605/article/details/80205734  
版权声明：本文为博主原创文章，转载请附上博文链接！

\--------------------------------------------------------------------------------------

[70]: /images/20220525/ea1a349a700d4a8f8d36be1ca73683b1.png
[70 1]: /images/20220525/6d7a0c4f7f05489f820753faf7db18c9.png