设计模式-单例设计模式

已于 2023-06-30 11:28:41 修改
阅读量1.8k 收藏
点赞数 3
分类专栏： 设计模式 文章标签： 设计模式 java 面试
于 2021-03-14 15:24:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/i_wonder_how_/article/details/114789766
版权

概念

顾名思义，就是确保某一个类在任何情况下都绝对只有一个实例，而且自行实例化并向外部提供一个该实例的全局访问点。这个类被称为单例类
单例模式是一种对象创建型模式

应用场景

  • 系统中只需要一个实例对象，如windows系统的资源管理器。
  • 客户调用类的单个实例，只允许使用一个全局访问点，除了该访问点，不能通过其他方式来访问该实例。

具体应用

image-20210314152121272
单例模式只有一个角色

  • Singleton(单例)：单例类对外隐藏了构造方法，在其内部只生成一个实例，同时它对外提供了一个静态的getInstance()工厂方法，让用户可以访问其唯一实例；在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例。

代码实践

负载均衡器的实现，将并发访问与数据流量分发至服务器集群中的多台设备上，提高整个系统的处理能力，缩短响应时间。
由于集群中的服务器在运行过程中会动态删减，且客户端的需求需要统一分发，因此需要确保负载均衡器的唯一性。

饿汉式单例

在单例类首次加载时就创建实例。
image-20210314152146495

class EagerLoadBalancer {
    //私有静态成员变量，存储唯一实例
    private static EagerLoadBalancer instance = new EagerLoadBalancer();
    //服务器集合
    private List serverList = null;

    //私有构造函数
    private EagerLoadBalancer() {
        serverList = new ArrayList();
    }

    //公有静态成员方法，返回唯一实例
    public static EagerLoadBalancer getLoadBalancer() {
        return instance;
    }

    //增加服务器
    public void addServer(String server) {
        serverList.add(server);
    }

    //删除服务器
    public void removeServer(String server) {
        serverList.remove(server);
    }

    //使用Random类随机获取服务器
    public String getServer() {
        Random random = new Random();
        int i = random.nextInt(serverList.size());
        return (String)serverList.get(i);
    }
}

当类被加载时，静态变量instance会被初始化，此时类的私有构造函数会被调用，单例类的唯一实例将被创建。

优点

由于是在单例类首次加载时就已经创建了实例，不会存在多线程情况下，出现多个实例的情况。

缺点

由于是在单例类首次加载时就已经创建了实例，所以不管最后有没有使用这个实例，该实例都已经存在了，会比较浪费内存空间

懒汉式单例（简单版）

在初始化时不去创建实例，而是在第一次需要使用的时候创建实例。
image-20210314152209381
由图可知，懒汉式单例在第一次调用getInstance方法时实例化，在类加载时并不自行实例化，这种技术又称为延迟加载。

public class LazyLoadBalancer {
    //私有静态成员变量，存储唯一实例
    private static LazyLoadBalancer instance = null;
    //服务器集合
    private List serverList = null;

    //私有构造函数
    private LazyLoadBalancer() {
        serverList = new ArrayList();
    }

    //公有静态成员方法，返回唯一实例
    public static LazyLoadBalancer getLoadBalancer() {
        if(instance == null){
            instance = new LazyLoadBalancer();
        }
        return instance;
    }

    //增加服务器
    public void addServer(String server) {
        serverList.add(server);
    }

    //删除服务器
    public void removeServer(String server) {
        serverList.remove(server);
    }

    //使用Random类随机获取服务器
    public String getServer() {
        Random random = new Random();
        int i = random.nextInt(serverList.size());
        return (String)serverList.get(i);
    }
}

这便是最基本的懒汉式单例，看起来似乎没有什么问题，实际上在多线程情况下，会出现多个实例的情况。
懒汉式单例 多线程测试

    public static void main(String[] args) {
        Thread th1 = new Thread(new Runnable() {
            @Override
            public void run() {
                LazyLoadBalancer loadBalancer = LazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th2 = new Thread(new Runnable() {
            @Override
            public void run() {
                LazyLoadBalancer loadBalancer = LazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th3 = new Thread(new Runnable() {
            @Override
            public void run() {
                LazyLoadBalancer loadBalancer = LazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        th1.start();
        th2.start();
        th3.start();
    }

测试结果
image-20210314152310254
可以看到出现了2个不同的实例

懒汉式单例（线程安全版）

简单版的懒汉式单例，有线程安全问题，在多线程情况下会出现多个实例，这违背了单例模式只有一个实例的规则，我们可以在简单版的基础上，在getInstance方法上加上synchronized关键字，但这样的话，每次调用时都会去进行线程锁定判断，对性能有极大的影响。所以不建议直接这样使用。但还是给出参考代码

public class SyncLazyLoadBalancer {
    //私有静态成员变量，存储唯一实例
    private static SyncLazyLoadBalancer instance = null;
    //服务器集合
    private List serverList = null;

    //私有构造函数
    private SyncLazyLoadBalancer() {
        serverList = new ArrayList();
    }

    //公有静态成员方法，返回唯一实例
    public static synchronized SyncLazyLoadBalancer getLoadBalancer() {
        if(instance == null){
            instance = new SyncLazyLoadBalancer();
        }
        return instance;
    }

    //增加服务器
    public void addServer(String server) {
        serverList.add(server);
    }

    //删除服务器
    public void removeServer(String server) {
        serverList.remove(server);
    }

    //使用Random类随机获取服务器
    public String getServer() {
        Random random = new Random();
        int i = random.nextInt(serverList.size());
        return (String)serverList.get(i);
    }

    public static void main(String[] args) {
        Thread th1 = new Thread(new Runnable() {
            @Override
            public void run() {
                SyncLazyLoadBalancer loadBalancer = SyncLazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th2 = new Thread(new Runnable() {
            @Override
            public void run() {
                SyncLazyLoadBalancer loadBalancer = SyncLazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th3 = new Thread(new Runnable() {
            @Override
            public void run() {
                SyncLazyLoadBalancer loadBalancer = SyncLazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        th1.start();
        th2.start();
        th3.start();
    }
}

懒汉式单例（性能优化版double check）

在线程安全版中，由于将synchronized关键字加在了整个方法上，导致锁的粒度太大，我们可以减小锁的粒度，将该关键字加载创建实例的代码上，以达到性能优化的目的。
但是这样线程安全的问题又出现了，因为加入在某一瞬间，线程A和线程B同时调用了该方法，此时，instance实例是为null的，所以2个线程均能进入创建实例的代码，但因为创建实例的代码是加了锁的，所以导致2个线程会排队进入创建实例的代码，线程A创建完实例后，线程B又创建了一个新实例。所以这个方式需要改进。
我们可以在synchronized中再次进行instance == null避免这种情况出现。这种方式称为双重检查锁定（double check）
这种方式虽然比较完美的解决了性能与线程安全问题，但是在Java虚拟机内部，可能会发生指令重排序，把一个对象的创建过程分为申请内存地址、变量初始化这2步的话有可能会出现刚申请好内存地址，另一个线程就拿到这个对象认为它被创建好了，就 直接拿出去用而引发线程安全问题，所以我们需要给对象加上volatile关键字，被这个关键字修饰的变量，可以防止指令重排序，对象在各个线程中是可见的，各个线程都能立即知道它的修改情况。
参考代码：

package com.donkeyx.pattern.factory.singleton.lazySingleton;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class DcLazyLoadBalancer {
    //私有静态成员变量，存储唯一实例
    private volatile static DcLazyLoadBalancer instance = null;
    //服务器集合
    private List serverList = null;

    //私有构造函数
    private DcLazyLoadBalancer() {
        serverList = new ArrayList();
    }

    //公有静态成员方法，返回唯一实例
    public static DcLazyLoadBalancer getLoadBalancer() {
        if(instance == null){
            synchronized (DcLazyLoadBalancer.class){
                if(instance == null){
                    instance = new DcLazyLoadBalancer();
                }
            }
        }
        return instance;
    }

    //增加服务器
    public void addServer(String server) {
        serverList.add(server);
    }

    //删除服务器
    public void removeServer(String server) {
        serverList.remove(server);
    }

    //使用Random类随机获取服务器
    public String getServer() {
        Random random = new Random();
        int i = random.nextInt(serverList.size());
        return (String)serverList.get(i);
    }

    public static void main(String[] args) {
        Thread th1 = new Thread(new Runnable() {
            @Override
            public void run() {
                DcLazyLoadBalancer loadBalancer = DcLazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th2 = new Thread(new Runnable() {
            @Override
            public void run() {
                DcLazyLoadBalancer loadBalancer = DcLazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th3 = new Thread(new Runnable() {
            @Override
            public void run() {
                DcLazyLoadBalancer loadBalancer = DcLazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        th1.start();
        th2.start();
        th3.start();
    }
}

懒汉式单例（静态内部类版）

静态内部类是懒汉式单例的最优解，它利用了JVM的加载机制，在内部类调用时才进行对象初始化，并且没有使用synchronized关键字，没有线程安全和性能问题，但是有被反射攻击的危险
参考代码

package com.donkeyx.pattern.factory.singleton.lazySingleton;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class InnerLazyLoadBalancer {

    /**
     * 使用一个静态内部类对单例对象进行创建动作
     */
    private static class Holder{
        private final static InnerLazyLoadBalancer instance = new InnerLazyLoadBalancer();
    }

    //服务器集合
    private List serverList = null;

    //私有构造函数
    private InnerLazyLoadBalancer() {
        serverList = new ArrayList();
    }

    //公有静态成员方法，返回唯一实例
    public static InnerLazyLoadBalancer getLoadBalancer() {
        return Holder.instance;
    }

    //增加服务器
    public void addServer(String server) {
        serverList.add(server);
    }

    //删除服务器
    public void removeServer(String server) {
        serverList.remove(server);
    }

    //使用Random类随机获取服务器
    public String getServer() {
        Random random = new Random();
        int i = random.nextInt(serverList.size());
        return (String)serverList.get(i);
    }

    public static void main(String[] args) {
        Thread th1 = new Thread(new Runnable() {
            @Override
            public void run() {
                InnerLazyLoadBalancer loadBalancer = InnerLazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th2 = new Thread(new Runnable() {
            @Override
            public void run() {
                InnerLazyLoadBalancer loadBalancer = InnerLazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th3 = new Thread(new Runnable() {
            @Override
            public void run() {
                InnerLazyLoadBalancer loadBalancer = InnerLazyLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        th1.start();
        th2.start();
        th3.start();
    }
}

枚举式单例

这是单例模式的最佳实现方法，它既没有线程安全问题与性能问题，也没有被反射攻击的危险。
因为Java虚拟机会保证枚举对象的唯一性，因此，每个枚举类型和定义的枚举变量在JVM中都是唯一存在的。
通过对枚举类进行反编译发现，其内部对象实际上实在静态代码块中直接被加载。这种方式与饿汉式一致，也就没有所谓的线程安全问题
枚举类型的对象在反序列化时，是通过类名和名称进行实例化的，这种类名+名称的方式必然只有一个对象，所以也避免了反序列化时破坏单例

参考代码

package com.donkeyx.pattern.factory.singleton.lazySingleton;

import cn.hutool.core.lang.Singleton;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class EnumLoadBalancer {
    //创建枚举对象
    public static enum LoadBalancerEnum{
        SINGLETON;
        private EnumLoadBalancer instance = null;

        private LoadBalancerEnum(){
            instance = new EnumLoadBalancer();
        }
        public EnumLoadBalancer getInstance(){
            return instance;
        }
    }
    //服务器集合
    private List serverList = null;

    //私有构造函数
    private EnumLoadBalancer() {
        serverList = new ArrayList();
    }

    //公有静态成员方法，返回唯一实例
    public static EnumLoadBalancer getLoadBalancer() {
        return LoadBalancerEnum.SINGLETON.getInstance();
    }

    //增加服务器
    public void addServer(String server) {
        serverList.add(server);
    }

    //删除服务器
    public void removeServer(String server) {
        serverList.remove(server);
    }

    //使用Random类随机获取服务器
    public String getServer() {
        Random random = new Random();
        int i = random.nextInt(serverList.size());
        return (String)serverList.get(i);
    }

    public static void main(String[] args) {
        Thread th1 = new Thread(new Runnable() {
            @Override
            public void run() {
                EnumLoadBalancer loadBalancer = EnumLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th2 = new Thread(new Runnable() {
            @Override
            public void run() {
                EnumLoadBalancer loadBalancer = EnumLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        Thread th3 = new Thread(new Runnable() {
            @Override
            public void run() {
                EnumLoadBalancer loadBalancer = EnumLoadBalancer.getLoadBalancer();
                System.out.println(loadBalancer);
            }
        });
        th1.start();
        th2.start();
        th3.start();
    }
}

优点

  • 单例模式提供了对唯一实例的受控访问，因为单例类封装了它的唯一实例，所以它可以严格控制用户怎么去访问
  • 由于在系统中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式可以提高系统性能

缺点

  • 单例模式没有抽象层，因此单例类的扩展有很大的困难
  • 单例类职责过重，违背单一职责原则。它既充当了工厂角色，提供了工厂方法，又充当了产品角色，包含了一些业务方法，将产品创建和产品功能融合在了一起
  • 运行环境的问题，在Java 或者C#这种提供了垃圾回收机制的 环境中，如果创建的实例长时间不使用，系统会将其标记为垃圾，会自动回收该实例，下次利用时，又将重新实例化，这将导致共享的单例对象状态丢失。
味无味_
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
1.设计模式-单例设计模式1
08-03
1.模式定义/应用场景/类图分析 2.字节码知识/字节码指令重排序 3.类加载机制 4.JVM序列化机制 5.单例模式在Spring框架 & JDK源码中的应用
单例模式（Singleton）的6种实现
以梦为马 不负韶华
02-26 622
单例模式（Singleton）的6种实现1.1 摘要 在我们日常的工作中经常需要在应用程序中保持一个唯一的实例，如：IO处理，数据库操作等，由于这些对象都要占用重要的系统资源，所以我们必须限制这些实例的创建或始终使用一个公用的实例，这就是我们今天要介绍的——单例模式（Singleton）。 ...
设计模式(一)单例模式
droidYu
02-11 762
单例设计模式（Singleton Design Pattern）理解起来非常简单。一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。 定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。 单例模式结构图如下： Client为客户端，Singleton为单例类，Client通过调用Singleton.getInstance()方法获取实例对象。 下面介绍常见的6种单例写法： 饿汉式 饿汉式的实现方式比较简单。在类加载的时候，instance
单例模式（单例设计模式）详解
GJ_007的博客
03-31 4万+
在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。 单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程
设计模式之单例模式详解（附应用举例实现）
pursuit的博客
04-22 4623
设计模式之单例模式详解（附应用举例实现），包含三种实现单例模式的方法
图解设计模式之单例模式
it_much_nice
10-15 635
1单例模式的UML图 注：本文中的UML图是根据自己的想法绘制的，并不是直接照抄，仅供学习参考 2.单例模式几种写法的比较 2.1 饿汉式 /** * 饿汉式 * 类加载到内存后，就实例化一个单例，JVM保证线程安全 * 简单实用，推荐使用！ * 唯一缺点：不管用到与否，类装载时就完成实例化 */ public class Singleton01 { private static final Singleton01 INSTANCE = new Singleton01(); p
ava常用设计模式-单例模式
08-26
ava常用设计模式-单例模式
Java设计模式-单例模式详解
11-24
Java设计模式-单例模式详解
常见设计模式-单例模式
07-06
单例模式，完整介绍单例模式的几种创建方式 以及对比优缺点，引用spring 源码简单分析 框架如何保证单例
c++设计模式-单例模式
06-03
c++设计模式-创建型模式-单例模式源码，懒汉式 饿汉式源码，qt工程，单例模式线程安全问题，单例模式实现方式
设计模式之——单例模式
很高兴你能看到这里
06-19 2218
更酷的是，创建对象的职责和管理单例的职责被拆分在两个不同的方法中，这两个方法组合起来才具有单例模式的威力。你学到了吗，少年？
单例设计模式(8种)
weixin_49329785的博客
08-04 1108
/* * 单例设计模式： * 1.所谓的单例设计模式，就是采用一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。 * * 2.如何实现？ * 饿汉式 vs 懒汉式 * 3.区分饿汉式和懒汉式 * 饿汉式：（创建时就已经存在对象） * 坏处：对象加载时间过长。 * 好处：饿汉式是线程安全的。 * 懒汉式： * 好处：延迟对象的创建 * 目前写法的坏处：线程不安全。---->到多线程内容时，在修改 * */ public class Si.
单例设计模式
qq_48157004的博客
05-28 2717
单例例模式便是创建型设计模式的一种，它确保某一个类在系统中只有一个实例，并自行实例化，同时向外部提供获取这个唯一实例的接口。单例设计模式主要有以下三个特点：1、只能有一个实例。2、必须自己创建自己的唯一实例。3、必须给所有其他对象提供这一实例。缺点： 以空间换时间，在实例化时就创建，灵活性不高，空间使用率不高。优点：在类加载过程中便会创建。由此带来的好处是Java的类加载机制本身为我们保证了实例化过程的线程安全性。
设计模式之单例模式（七种方法超详细）
weixin_63834061的博客
04-22 3700
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，也就是说不能使用new关键字来创建对象。
什么是单例模式
qq_22339269的博客
05-13 1万+
原文：https://zhuanlan.zhihu.com/p/51854665 什么是单例模式？ 保证整个系统中一个类只有一个对象的实例，实现这种功能的方式就叫单例模式。 为什么要用单例模式? 1、单例模式节省公共资源 比如：大家都要喝水，但是没必要每人家里都打一口井是吧，通常的做法是整个村里打一个井就够了，大家都从这个井里面打水喝。 对应到我们计算机里面，像日志管理、打印机、数据库...
单例模式（Singleton)
weixin_61196797的博客
06-14 1473
第一章:单例模式定义：为什么要使用单例模式？单例模式的结构：在创建单例模式前，我们先来了解一下static关键字特点优点：全局变量不会被其他分支文件远程访问，修改在其他文件中可以使用和static关键字修饰的相同字段，不会冲突局部变量作用域仍为局部作用域，当定义该静态局部变量符号或局部函数语句块结束时，作用域随之结束、函数静态函数不能被项目工程中其他文件所调用这里例是类的定义 测试： 代码运行结果 返回1说明两次创建的实例相等 我们通过控制instance类方法来获取FKSingleton实例时，程序最多只
单例模式详解
欢迎一起学习交流
04-29 2万+
一、什么是单例模式 单例模式是Java中最简单的设计模式之一。这种类型的设计模式属于创建者模式，它提供了一种访问对象的最佳方式。 这种设计模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。 二、单例模式的结构 单例类：只能创建一个实例的类 访问类：使用单例类的类 三、单例模式分类 饿汉式：类加载就会导致该单实例对象被创建 懒汉式：类加载不会导致该单实例对象被创...
【C++】C++ 单例模式总结（5种单例实现方法）
unonoi的博客
11-04 7万+
C++ 单例模式的几种实现方式。
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 98万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
聊聊设计模式-单例模式
最新发布
09-29
单例模式是一种创建型设计模式，它保证类仅有一个实例，并提供一个全局访问点。在单例模式中，类会自行创建一个实例，并对外提供一个访问该实例的方法。 单例模式有多种实现方式，其中常见的有懒汉式和饿汉式。懒汉...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值