单例模式

最新推荐文章于 2023-06-11 20:34:20 发布
最新推荐文章于 2023-06-11 20:34:20 发布
阅读量125 收藏
点赞数
分类专栏： 面试 设计模式 文章标签： 设计模式 java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42272869/article/details/115589691
版权

单例模式

1.单例介绍

  • 保证一个类只有一个实例，并且该类提供一个访问的全局访问点

2.单例模式使用场景

  1. 计数器，一般也是采用单例模式实现，否则难以同步。
  2. 应用程序的日志应用，一般都是单例模式实现，只有一个实例去操作才好，否则内容不好追加显示。
  3. 线程池的设计一般也是采用单例模式，因为线程池要方便对池中的线程进行控制
  4. 任务管理器就是很典型的单例模式，他不能打开俩个
  5. 回收站也是典型的单例应用。在整个系统运行过程中，回收站只维护一个实例。

3.优缺点

优点：

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

缺点：

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

4.使用注意事项：

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

5.单例创建方式

（主要使用懒汉和懒汉式）

  1. 饿汉式:类初始化时,会立即加载该对象，线程天生安全,调用效率高。
  2. 懒汉式: 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。
  3. 静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。
  4. 枚举单例: 使用枚举实现单例模式 优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞， 缺点没有延迟加载。
  5. 双重检测锁方式 (因为JVM本质重排序的原因，可能会初始化多次，不推荐使用)
1.饿汉式（线程安全）
  1. 饿汉式:类初始化时,会立即加载该对象，线程天生安全,调用效率高。
package com.lijie;

//饿汉式
public class Demo1 {

    // 类初始化时,会立即加载该对象，线程安全,调用效率高
    private static Demo1 demo1 = new Demo1();

    private Demo1() {
        System.out.println("私有Demo1构造参数初始化");
    }

    public static Demo1 getInstance() {
        return demo1;
    }

    public static void main(String[] args) {
        Demo1 s1 = Demo1.getInstance();
        Demo1 s2 = Demo1.getInstance();
        System.out.println(s1 == s2);
    }
}
2.懒汉式（若没加sy…，线程不安全）
  1. 懒汉式: 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。
package com.lijie;

//懒汉式
public class Demo2 {

    //类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象。
    private static Demo2 demo2;

    private Demo2() {
        System.out.println("私有Demo2构造参数初始化");
    }

    public synchronized static Demo2 getInstance() {
        if (demo2 == null) {
            demo2 = new Demo2();
        }
        return demo2;
    }

    public static void main(String[] args) {
        Demo2 s1 = Demo2.getInstance();
        Demo2 s2 = Demo2.getInstance();
        System.out.println(s1 == s2);
    }
}
3.静态内部类
  1. 静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。
package com.lijie;

// 静态内部类方式
public class Demo3 {

    private Demo3() {
        System.out.println("私有Demo3构造参数初始化");
    }

    public static class SingletonClassInstance {
        private static final Demo3 DEMO_3 = new Demo3();
    }

    // 方法没有同步
    public static Demo3 getInstance() {
        return SingletonClassInstance.DEMO_3;
    }

    public static void main(String[] args) {
        Demo3 s1 = Demo3.getInstance();
        Demo3 s2 = Demo3.getInstance();
        System.out.println(s1 == s2);
    }
}
4.枚举单例式
  1. 枚举单例: 使用枚举实现单例模式 优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞， 缺点没有延迟加载。
package com.lijie;

//使用枚举实现单例模式 优点:实现简单、枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞 缺点没有延迟加载
public class Demo4 {

    public static Demo4 getInstance() {
        return Demo.INSTANCE.getInstance();
    }

    public static void main(String[] args) {
        Demo4 s1 = Demo4.getInstance();
        Demo4 s2 = Demo4.getInstance();
        System.out.println(s1 == s2);
    }

    //定义枚举
	private static enum Demo {
		INSTANCE;
		// 枚举元素为单例
		private Demo4 demo4;

		private Demo() {
			System.out.println("枚举Demo私有构造参数");
			demo4 = new Demo4();
		}

		public Demo4 getInstance() {
			return demo4;
		}
	}
}
5.双重检测锁方式
  1. 双重检测锁方式 (因为JVM本质重排序的原因，可能会初始化多次，不推荐使用)
package com.lijie;

//双重检测锁方式
public class Demo5 {

	private static Demo5 demo5;

	private Demo5() {
		System.out.println("私有Demo4构造参数初始化");
	}

	public static Demo5 getInstance() {
		if (demo5 == null) {
			synchronized (Demo5.class) {
				if (demo5 == null) {
					demo5 = new Demo5();
				}
			}
		}
		return demo5;
	}

	public static void main(String[] args) {
		Demo5 s1 = Demo5.getInstance();
		Demo5 s2 = Demo5.getInstance();
		System.out.println(s1 == s2);
	}
}

6. 反射破坏单例

下面的代码可以看到，利用反射，是可以破坏单例的，两次newInstance会调用类的初始化方法进行对象的创建

public class Test1 {

    private static Test1 help = new Test1();

    private Test1() {
    }

    public static Test1 getInstance() {
        return help;
    }

    public static void main(String[] args) {
        try {
            Class<?> clazz = Test1.class;

            Constructor c = clazz.getDeclaredConstructor(null);

            c.setAccessible(true);

            Object object = c.newInstance();

            Object object1 = c.newInstance();

            System.out.println(object == object1); // false
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
6.1.单例防止反射漏洞攻击

根据反射的newInstance方法会调用该类的构造函数，所以在构造函数中进行限制

private static boolean flag = false;

private Singleton() {

	if (flag == false) {
		flag = !flag;
	} else {
		throw new RuntimeException("单例模式被侵犯！");
	}
}

public static void main(String[] args) {

}

或者：

public class Test1 {

    private static Test1 help = new Test1();

    private Test1() {
        if (help != null) {
            throw new RuntimeException("不允许创建多个实例");
        }
    }

    public static Test1 getInstance() {
        return help;
    }

    public static void main(String[] args) {
        try {
            Class<?> clazz = Test1.class;

            Constructor c = clazz.getDeclaredConstructor(null);

            c.setAccessible(true);

            Object object = c.newInstance();

            Object object1 = c.newInstance();

            System.out.println(object == object1); // false
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

7. 序列化破坏单例

序列化的对象和手动创建的对象是不一致的，实例化了两次，违背了单例模式的设计初衷

import java.io.Serializable;

//反序列化时导致单例破坏
public class SeriableSingleton implements Serializable {

    //序列化就是说把内存中的状态通过转换成字节码的形式
    //从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
    //内存中状态给永久保存下来了

    //反序列化
    //讲已经持久化的字节码内容，转换为IO流
    //通过IO流的读取，进而将读取的内容转换为Java对象
    //在转换过程中会重新创建对象new

    public  final static SeriableSingleton INSTANCE = new SeriableSingleton();
    private SeriableSingleton(){}

    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }
}

// 测试类

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SeriableSingletonTest {
    public static void main(String[] args) {

        SeriableSingleton s1 = null;
        SeriableSingleton s2 = SeriableSingleton.getInstance();

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();


            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SeriableSingleton)ois.readObject();
            ois.close();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
7.1.单例防止反射漏洞攻击

反序列化是不会调用类的构造函数的，所以不能像上面一样通过在构造函数中进行限制来防止单例被破坏。

//反序列化时导致单例破坏
public class SeriableSingleton implements Serializable {

    //序列化就是说把内存中的状态通过转换成字节码的形式
    //从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
    //内存中状态给永久保存下来了

    //反序列化
    //讲已经持久化的字节码内容，转换为IO流
    //通过IO流的读取，进而将读取的内容转换为Java对象
    //在转换过程中会重新创建对象new

    public  final static SeriableSingleton INSTANCE = new SeriableSingleton();
    private SeriableSingleton(){}

    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }
	// 增加readResolve方法即可
    private  Object readResolve(){
        return  INSTANCE;
    }

}

增加readResolve方法即可，需要阅读相应的s1 = (SeriableSingleton)ois.readObject();方法的源码才需要知晓。
具体的是思想是，增加了readResolve()方法返回实例解决了单例模式被破坏的问题，但是还是实例化了两次，只是新创建的对象没有被返回而已。

8.单例创建方式的选择

  • 如果不需要延迟加载单例，可以使用枚举或者饿汉式，相对来说枚举性好于饿汉式。
  • 如果需要延迟加载，可以使用静态内部类或者懒汉式，相对来说静态内部类好于懒韩式。
    最好使用饿汉式
pan_mlpan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++项目实战——基于多设计模式下的同步&异步日志系统-⑪-日志器管理类与全局建造者类设计（单例模式）
花想云的博客
10-16 765
C++项目实战——基于多设计模式下的同步&异步日志系统-⑪-日志器管理类与全局建造者类设计（单例模式）
3.4 单例模式在日志管理中的实际应用
xiaohaopei的博客
08-30 1634
作为非常简单的单例模式，其实现方法就是定义一个该类的静态变量，然后再定义一个获取该静态变量的静态方法。单例模式在程序开发中有着广泛的应用，比如数据库连接池，日志管理等都会使用到，学习设计模式最好的办法就是看好的代码，Log4j是Apache的一个开放源代码项目，得益于它良好的架构设计，开发人员可以随意控制日志语句的输出，输出的目的地可以是控制台，文件，邮件，数据库等。在Log4j中就用到了单例模式...
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
08-03
2020-02-10 王争设计模式之美进入课程讲述：冯永吉时长 10:21大小 8.31M上两节课中，我们针对单例模式，讲解了单例的应用场景、几种常见的代码实现
单例模式与阻塞队列实现异步的日志系统
qq_41895640的博客
12-28 1635
单例模式与阻塞队列实现异步的日志系统阻塞队列定义实现(c++11)单例模式定义类型懒汉式（编程使用）饿汉式C++中static对象的初始化non-local static对象（函数外）local static 对象（函数内）异步写日志 阻塞队列 定义 在多线程编程中阻塞队列是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于，当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素；当队列满时，往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出 在c++标准库STL中常用
设计模式：饿汉式和懒汉式单例模式（C++实现）以及日志系统的实现
zsiming的博客
09-09 1064
在一个项目的日志系统里面，我们常常会发现日志模块的实现是使用单例模式。单例模式的特点和它的名字一样，就是一个类能且只能实例化出一个唯一的对象。那么这样做有什么好处呢？
tinyWebServer 学习笔记——四、日志系统
BeZer0的学习笔记
05-15 5685
public :// C++11以后，使用局部变量懒汉不用加锁 static Log * get_instance() {} // 可选择的参数有日志文件、日志缓冲区大小、最大行数以及最长日志条队列 bool init(const char * file_name , int close_log , int log_buf_size = 8192 , int split_lines = 5000000 , int max_queue_size = 0);
用 C 语言编写设计模式--单例模式 (log日志文件的实现)
最新发布
weixin_46564301的博客
06-11 957
单例模式是一种属于对象创建型的模式，即保证系统中类只生成一个对象。这个是一个十分常用的设计模式，比如系统中只初始化一次的资源，如 socket、log 日志文件等，能被多个线程访问，保证其有唯一 1 个实列存在，作为全局变量供其他地方访问，同时也避免重复资源被初始化操作带来错误。简而言之，就是对一个一次性资源的封装，避免被重复申请或初始化，然后作为一个全局变量被访问。单例模式有如下几个特点：1.确保该资源只被申请或初始化一次 2.定义静态对象指针 3.提供一个函数，全局访问👀。
单例模式介绍
12-15
android 六种单例模式源码介绍，反序列化解决方案，编译环境为android studio 3.0.1
使用单例模式创建学生管理系统（饿汉式、懒汉式）
04-28
使用单例模式创建学生管理系统（饿汉式、懒汉式）
C#单例模式
09-09
C#单例模式的应用，这里给的是C#里面一个单例模式的应用案例，面向对象过程中不可避免的需要用到单例模式，我在博客园中有详细说明单例模式怎么应用的，链接地址：...
.Net 单例模式(Singleton)
01-02
 单例模式 Singleton Pattern 问题解决： （1）单例模式简介： Singleton模式要求一个类有且仅有一个实例，并且提供了一个全局的访问点。这就提出了一个问题：如何绕过常规的构造器，提供一种机制来保证一个类只有...
设计模式之单例模式（Singleton），以C++为例，实现日志输出。
Bobowen的博客
03-17 921
单例模式只保证一个程序内只有一个实例存在，并提供全局访问点来访问该实例，其实就是单例模式的类对象只允许存在一个，它和多线程思想恰恰相反，为的是保证操作资源的安全。比如日志系统需要记载时间的，如果多线程会搞得很乱。实现单例模式的关键是构造函数需要被设为私有，以防止外部代码创建多个实例。同时，需要提供一个静态方法来获取实例，这个方法会检查是否已经有一个实例存在，如果存在就返回这个实例，否则就创建一个新的实例并返回。
log日志--单例模式、静态类、宏、实现对比
天道酬勤
10-08 833
log文件--单例模式、静态类、宏、实现对比1 介绍2 单利模式3 静态类4 宏参考 1 介绍 2 单利模式 3 静态类 4 宏 参考 1、C++——之基于单例模式的日志输出 2、宏定义日志输出 3、C++ 日志宏定义 4、宏–C++实现一个简洁而又强大的日志记录类 ...
基于单例模式的日志输出(C++)
West.C.的博客
07-20 2527
本篇博客是基于实验楼12期楼赛第二题进行修改得到的。 　　赛题描述如下: 　　在软件运行中，系统一般会采用一个持久化的日志系统来记录运行情况。 　　本题你需要实现一个简易的 logger 日志类，这个类主要负责辅助调试，将日志信息输出到一个日志文件中。 　　比赛预期的输出为同一目录下的 shiyanloulogger.log日志文件，文件的内容如下： shiyanlou logger
线程池web服务器(8) 日志系统(条件变量，单例模式，阻塞队列)
ziggy7的博客
06-22 1391
整体概述 本项目中，使用单例模式创建日志系统，对服务器运行状态、错误信息和访问数据进行记录，该系统可以实现按天分类，超行分类功能，可以根据实际情况分别使用同步和异步写入两种方式。 其中异步写入方式，将生产者-消费者模型封装为阻塞队列，创建一个写线程，工作线程将要写的内容push进队列，写线程从队列中取出内容，写入日志文件。 日志系统大致可以分成两部分，其一是单例模式与阻塞队列的定义，其二是日志类的定义与使用。 基础知识 ●日志，由服务器自动创建，并记录运行状态，错误信息，访问数据的文件。 ●同步日志，日志写
二、单例模式
qq23001186的博客
03-09 135
.一、设计模式分类二、单例模式1、什么是单例2、单例应用场景3、单例优缺点三、单例创建方式1、饿汉式2、懒汉式3、静态内部类实现单例4、枚举单例a）枚举简介b）枚举创建单例5、双重检测锁方式 一、设计模式分类 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模
单例模式学习
qq_54088653的博客
08-16 52
单例模式 1、饿汉模式 对象在类加载时创建，线程安全，但是浪费内存 package com.wanna.单例模式; /** * 饿汉模式 * 对象在类加载时创建 * 线程安全，但是浪费内存 */ public class EHan { private EHan(){}; private static EHan instance=new EHan(); public static EHan getInstance(){ return instance;

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值