设计模式学习：一、单例模式

最新推荐文章于 2024-07-08 17:49:05 发布
最新推荐文章于 2024-07-08 17:49:05 发布
阅读量111 收藏
点赞数
文章标签： java 设计模式 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zengxiaoshuai1/article/details/105653340
版权

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

缺点
(1) 单例模式没有抽象层，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。
(2) 单例类的职责过重，在一定程度上违背了“单一职责原则”。
(3) 滥用单例将带来一些负面问题，如：为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；
又比如：在多个线程中操作单例类的成员时，但单例中并没有对该成员进行线程互斥处理。

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

饿汉：

/**
 * 饿汉式单例（提前把对象创建）
 * 可能会浪费空间，提前把对象创建好了，但是不一定会用。
 * 但是它是线程安全的
 */
public class Hungry {
	//构造方法私有
    private Hungry(){

    }
    //final实例化一个私有的对象
    //两个private保证了在其他地方不能实例化对象
    private final static Hungry HUNGRY=new Hungry();
	
	//通过静态方法，暴露实例到全局
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

懒汉式：
单线程下可用，多线程下不可用，存在多线程并发问题。

/**
 * 懒汉式单例（当使用时再创建对象）
 * 单线程下可用
 */
public class LazyMan {

    private LazyMan(){

    }
    private static LazyMan lazyMan;

    public LazyMan getInstnce(){
    //多个线程同时到这里，都进这个if，可以有多个实例
        if(lazyMan==null){
            lazyMan=new LazyMan();
        }
        return lazyMan;
    }
}

用多线程并发测试：（多次运行，查看打印结果，会发现个别有不同的实例）

public class LazyMan {

    private LazyMan(){

        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if(lazyMan==null){
            lazyMan=new LazyMan();
        }
        return lazyMan;
    }

    //多线程并发测试
    public static void main(String[] args){
        for(int i=0;i<10;i++){
            new Thread(()->{
                lazyMan.getInstance();
            }).start();
        }
    }
}

于是进阶为（加锁）DCL懒汉式（成为双重检测锁模式）：

public class LazyMan {

    private LazyMan(){

        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例，DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if(lazyMan==null){
                    lazyMan=new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    //多线程并发测试
    public static void main(String[] args){
        for(int i=0;i<10;i++){
            new Thread(()->lazyMan.getInstance()
            ).start();
        }
    }
}

每一个线程开启，都只是同一个单例对象。

DCL懒汉式单例再改进（添加volatle消除指令重排）：

public class LazyMan {

    private LazyMan(){

        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例，DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if(lazyMan==null){
                    lazyMan=new LazyMan();//不是原子性操作
                    /**不是原子性操作会发生以下三操作
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     *
                     * 会导致123或132顺序执行
                     * 若A线程顺序是132，又来了一个B线程，
                     * 则此时lazyMan没有完成构造，则会发生问题。(指令重排)
                     */
                }
            }
        }
        return lazyMan;
    }

    //多线程并发测试
    public static void main(String[] args){
        for(int i=0;i<10;i++){
            new Thread(()->lazyMan.getInstance()
            ).start();
        }
    }
}

静态内部类单例：

/**
 * 静态内部类
 */
public class Holder {

    private Holder(){

    }

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static class InnerClass{
        private static final Holder HOLDER=new Holder();
    }
}

以上单例方法都有问题，因为存在反射技术！！！
演示反射破解（两重检测锁模式）DCL进阶版懒汉式：

	//反射
    public static void main(String[] args) throws Exception {
        LazyMan instance1 = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
    }

在这里插入图片描述
进阶：在无参构造器中进行判断（成为三层检测锁模式），再执行，
判断，抛异常来保证实例只有一个：

public class LazyMan {

    private LazyMan(){
        synchronized (LazyMan.class){
            if(lazyMan!=null){
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例，DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if(lazyMan==null){
                    lazyMan=new LazyMan();//不是原子性操作
                    /**不是原子性操作会发生以下三操作
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     *
                     * 会导致123或132顺序执行
                     * 若A线程顺序是132，又来了一个B线程，
                     * 则此时lazyMan没有完成构造，则会发生问题。
                     */
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws Exception {
        LazyMan instance1 = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
    }
}

在这里插入图片描述
从这里开始可能是我的理解还不到位，只能是先保留收藏
使用反射再次破解时，把两个对象都用反射的方法newInstance() 创建出来：

//反射
    public static void main(String[] args) throws Exception {
//        LazyMan instance1 = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
    }

在这里插入图片描述
进阶：采用红路灯(添加muzi属性)，再执行：

public class LazyMan {

    private static boolean muzi=false;

    private LazyMan(){

        synchronized (LazyMan.class){
            if(muzi==false){
                muzi=true;
            } else{
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }

    }
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的懒汉式单例，DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if(lazyMan==null){
                    lazyMan=new LazyMan();//不是原子性操作
                    /**不是原子性操作会发生以下三操作
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     *
                     * 会导致123或132顺序执行
                     * 若A线程顺序是132，又来了一个B线程，
                     * 则此时lazyMan没有完成构造，则会发生问题。
                     */
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws Exception {
//        LazyMan instance1 = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
    }
}

在这里插入图片描述
反射破解（通过反射获取muzi属性，并修改）：

//反射
    public static void main(String[] args) throws Exception {
//        LazyMan instance1 = LazyMan.getInstance();
        Field muzi = LazyMan.class.getDeclaredField("muzi");
        muzi.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);

        LazyMan instance1 = declaredConstructor.newInstance();
        muzi.set(instance1,false);
        LazyMan instance2 = declaredConstructor.newInstance();


        System.out.println(instance1);
        System.out.println(instance2);
    }

在这里插入图片描述
枚举

/**
 * 枚举
 */
public enum  EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

上面是自己学习单例总结内容，单例看似简单的设计模式，其实用好了还是有难度的，我学习之后还有部分不是很了解，希望在今后自己水平提升之后能更好的理解单例模式。

行动代号JAVA
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
设计模式学习之单例模式
Piratesa的博客
07-19 81
一、单例模式实现方式 常见的 1、饿汉方式 示例代码: package com.mt.singleton; /** * 设计模式单例模式之饿汉实现方式 * 线程安全，调用效率高，但无法实现延迟加载 * @author MT * */ public class SingletonDemo1 { private static SingletonDemo1 s = new Singleton...
设计模式学习-单例模式
elricboa的专栏
03-12 314
最近开始学习一些设计模式相关内容，这篇文章也不算是完全原创，大部分来自于左潇龙大神讲解单例模式的博客不同写法中一些关键点的总结。 单例模式是最常见的也是用的最多的设计模式之一，判断是否单例模式可以通过一个类是否是单例就看在整个应用中同一时刻，只有一个状态，如果有两个或两个以上实例就会发生错误 目的：节约内存空间和减小GC消耗 饿汉模式：每一次访问其他静态域都会实例化创建新对象开销
设计模式学习笔记：单例模式
qq_40409117的博客
05-06 797
单例模式 【2021版】马士兵重讲23种设计模式，居然能这么通俗易懂_哔哩哔哩_bilibili 单例模式的常见应用场景 - 简书 单例模式 | 菜鸟教程 (runoob.com) Singleton 单例即只有一个实例。 当整个程序中，某个对象只需要有一个唯一的实例存在的时候，就可以使用单例模式。 例如： 在确定某个对象在整个程序只会有唯一的一个实例时，可以在代码中加一些限制，保证他只有一个实例（比如不能被别人new出来第二个实例等），这种编程方式就叫单例模式。 名称：单例模式Si
Java设计模式详解：单例模式
Jz_Stu的博客
03-31 1012
通过掌握单例模式的原理、案例和使用场景，我们可以更加灵活地运用它来解决实际开发中的问题。希望这篇文章能够帮助大家更好地理解和应用单例模式，为后续的Java学习和实践打下坚实的基础。
设计模式学习之——单例模式
m0_70289867的博客
06-19 1097
单例模式
设计模式C++学习之单例模式（Singleton）
09-07
单例模式是软件设计模式中的一种，它保证一个类只有一个实例，并提供一个全局访问点。在C++中，实现单例模式有多种方法，我们将会深入探讨这一模式的原理、优缺点以及如何在实际编程中应用。 单例模式的核心在于...
C#设计模式–单例模式
12-22
　近在学设计模式的一些内容，主要的参考书籍是《Head First 设计模式》，同时在学习过程中也查看了很多博客园中关于设计模式的一些文章的，在这里记录下我的一些学习笔记，一是为了帮助我更深入地理解设计模式，二...
菜鸟学习java设计模式之单例模式
08-28
单例模式是软件设计模式中的一种基础模式，用于确保一个类只有一个实例，并提供一个全局访问点。在Java中，单例模式的实现有很多种方式，包括懒汉式、饿汉式、双重检查锁定（DCL）等。下面我们将深入探讨这些实现...
学习JavaScript设计模式之单例模式
11-24
一、定义 保证一个类仅有一个实例，并...全局变量不是单例模式，但在JavaScript开发中，我们经常会把全局变量当成单例来使用。 var a = {}; 降低全局变量带来的命名污染 （1）使用命名空间 var namespace1 = { a:
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 577
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 906
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
Java面试题: 什么情况下索引会失效
qq_55630615的博客
07-02 407
通过执行计划EXPLAIN可以判断索引是否失效如果KEY和KEY_LEN为空代表索引失效。
ShardingSphere
Casual_Lei的博客
07-04 688
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
maven配置使用nexus仓库
ApexPredator的博客
07-03 251
maven配置使用nexus仓库
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 948
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
基于SpringBoot的招聘信息管理系统的详细设计和实现(源码+lw+部署文档+讲解等，欢迎咨询我！！)
程序员阿龙的博客
07-06 895
本次分享的是一个基于java开发的招聘信息管理系统，也说明了自己的开发实力，欢迎各位小伙伴来咨询相关业务，也可以参考一下这个文章！！
JavaSE阶段面试题（一）
tq02的博客
07-03 640
本章节主要讲述SE阶段的常见面试题
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 275
定义返回值类型处理器的组合；测试使用的controller测试方法。
学习mybatis
最新发布
weixin_45621552的博客
07-08 435
【代码】学习mybatis。
软件工程设计模式基础.pdf
11-19
软件工程设计模式基础是一本深入探讨软件开发中常用的设计模式和技术的教材，它涵盖了软件工程的各个方面，尤其是使用统一建模语言UML（Unified Modeling Language）进行系统建模，包括用例图、类图、对象图、包图和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值