设计模式-单例模式

最新推荐文章于 2024-10-17 16:31:31 发布

呼风bg

最新推荐文章于 2024-10-17 16:31:31 发布

阅读量176

点赞数

分类专栏：设计模式文章标签：设计模式 java

本文链接：https://blog.csdn.net/qq_43698792/article/details/117625661

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的单例模式，包括懒汉式和饿汉式的实现方式及其优缺点。讨论了单例模式在减少内存开支、优化资源访问等方面的应用，并提醒了在分布式系统和多类加载器环境下的注意事项。同时，提供了单例模式的测试代码，展示了不同实现方式的线程安全性。

摘要由CSDN通过智能技术生成

一、定义

Ensure a class has only one isntance, and provide a global point of access to it.

确保一个类只有一个实例，而且自行实例化并像整个系统提供这个实例。
单例模式分为懒汉式和饿汉式两种模式：
- 懒汉式：只有第一次引用类时菜进行对象实例化
- 饿汉式：类加载时就会实例化对象

二、单例模式的应用

1、单例模式的有点

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

2、单例模式的缺点

单例模式无法创建子类、扩展困难，若要扩展，除了修改代码基本没有第二种途径可以实现
单例模式对测试不利，单例模式的类通常不会实现接口，这妨碍了使用mock的方式虚拟对象
单例模式与单一职责原则有冲突，一个类只实现一个逻辑，而不关心它是否是单例的，是不是要用到哪里模式取决于环境，单例模式把“要单例”和业务逻辑融合在一起

3、单例模式的使用场景

在一个系统中，如果要求一个类有且仅有一个实例，当出现多个实例时会造成不良反应，则此时应该使用单例模式。
要求生成唯一序列号的环境
在项目中需要一个共同访问点和共享数据，例如：web计数器
创建一个对象消耗的资源过多，例如：IO和数据库资源
需要定义大量的静态常量和静态方的环境，

4、单例的注意事项

根据功能，单例类可以分为有状态单例类和无状态单例类。

有状态单例类：一个有状态单例类的对象一般是可变的，通常当做状态库使用。例如，给系统提供一个唯一的序列号。
无状态单例类：无状态单例类是不变的，通常用来提供工具性的功能方法。例如， IO或数据库访问等。
因为单例类具有状态，所以在使用时应注意以下两点。
单例类仅局限于一个JVM，因此当多个JVM的分布式系统时，这个单例类就会在多个JVM中被实例化，造成多个单例对象的出现。如果是无状态的单例类，则没有问题，因为这些单例对象是没有区别的。如果是有状态的单例类，则会出现问题，例如，给系统提供一个唯一的序列号，此时序列号不唯一，可能出现多次。因此，在任何使用EJB、RMI和JINI技术的分布式系统中，应当避免使用有状态的单例类。
同一个JVM中会有多个类加载器，当两个类加载器同时加载同一个类时，会出现两个实例，此时也应尽量避免使用有状态的单例类。
另外，使用单例模式时，需要注意序列化和克隆对实例唯一性的影响。如果一个单例的类实现了Serializable或Cloneable接口，则有可能被反序列化或克隆出一个新的实例来，从而破坏了“唯一实例”的要求，因此，通常单例类不需要实现Serializable和Cloneable接口。

三、测试代码

1、懒汉式

package com.bbg.design_patterns.singleton;

/**
 * 设计模式-单例设计模式(懒汉式：内存占用大，且创建复杂）
 */
public class SingletonLazy {

    private static volatile SingletonLazy instance = null;

    private int num = 0;

    /**
     * 私有化构造函数，此时不会再生成默认构造函数，通过getInstance获取实例
     * 由于构造函数是私有的因此该类无法被继承
     */
    private SingletonLazy(){
        System.out.println("构造SingletonLay");
    }

    public synchronized int getNum(){
        return ++num;
    }

    /**
     * 线程不安全。当两个线程同时判断instance==null时，会创建不止一个实例
     * @return
     */
    public static SingletonLazy getInstance1(){
        if (instance == null){
            instance = new SingletonLazy();
        }
        return instance;
    }

    /**
     * 相对方法2，线程安全，但是synchronize锁的性能开销很大，获得方法锁的线程正常执行的时候其他线程都会被阻断
     * @return
     */
    public static synchronized SingletonLazy getInstance2(){
        if (instance == null){
            instance = new SingletonLazy();
        }
        return instance;
    }

    /**
     * 相对方法2针对局部代码块进行加锁，但是同样存在线程安全问题，比较鸡肋
     * 两个线程同时进入了代码块，此时只是锁住了创建实例的部分，实际毫无作用
     * @return
     */
    public static SingletonLazy getInstance3(){
        if (instance == null){
            synchronized (SingletonLazy.class){
                instance = new SingletonLazy();
            }
        }
        return instance;
    }

    /**
     * 最优方法，线程安全，既减少了加锁步骤的性能开销，同时使用了DCL双重锁定保证了只会出现一个实例
     * @return
     */
    public static SingletonLazy getInstance4(){
        if (instance == null){
            synchronized (SingletonLazy.class){
                if (instance == null){
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }


}

2、饿汉式

package com.bbg.design_patterns.singleton;

/**
 * 设计模式-单例设计模式(饿汉式：内存占用不大，创建简单可以直接使用饿汉式，不存在线程安全问题）
 */
public class SingletonHungry {

    private static SingletonHungry instance = new SingletonHungry();

    private SingletonHungry(){}

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

3、测试用例

package com.bbg.design_patterns.singleton;

/**
 * @author hufeng
 */
public class SingletonTest {

    public static void main(String[] args) {
        NumThread numThreadA = new NumThread("A");
        NumThread numThreadB = new NumThread("B");
        numThreadA.start();
        numThreadB.start();
    }
}

class NumThread extends Thread{

    private String threadName;

    public NumThread(String name){
        this.threadName = name;
    }

    public void run() {
        SingletonLazy singletonLazy = SingletonLazy.getInstance4();

        for (int i = 0 ; i < 10 ; i++){
            System.out.println(threadName + "第" + singletonLazy.getNum() + "次访问");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4、运行结果

构造SingletonLay
A第1次访问
B第2次访问
B第3次访问
A第4次访问
A第5次访问
B第6次访问
A第7次访问
B第8次访问
A第9次访问
B第10次访问
A第11次访问
B第12次访问
A第13次访问
B第14次访问
A第16次访问
B第15次访问
A第17次访问
B第18次访问
A第19次访问
B第20次访问