Java设计模式之五种单例模式

最新推荐文章于 2022-01-28 18:00:35 发布
最新推荐文章于 2022-01-28 18:00:35 发布
阅读量372 收藏
点赞数
分类专栏： 设计模式 文章标签： java设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bruceleenumberone/article/details/73865418
版权

一、设计模式分类

将设计者的思维融入大家的学习和工作中，思维和思考方式的转变，重要的是学习思维和思考的方式。
GOF23种设计模式，全称是Group Of Four 23中设计模式。

1.1 创建型模式

创建型模式主要是用来帮助人们创建对象，具体包括以下几种：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式

1.2 结构型模式

核心作用：是从程序的结构上实现松耦合，从而可以扩大整体的类结构，用来解决更大的问题。

适配器模式、代理模式、桥接模式、装饰模式、组合模式、外观模式、享元模式

1.3 行为型模式

行为型模式关注系统中对象之间的相互交互，研究系统在运行的对象之间的相互通信和协作，进一步明确对象的职责，共有11种模式。

模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式


二、五种单例模式

核心作用：
保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
常见应用场景：
1) Windows的Task Manager(任务管理器)就是很典型的单例模式；
2) Windows的Recycle Bin(回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
3) 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。
4) 网站的计数器，一般也是采用单例模式实现，否则难以同步。
5) 应用程序的日志应用，一般都可用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
6) 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
7) 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
8) Application也是单例的典型应用(Servlet编程中会涉及到)。
9) 在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理。
10) 在Servlet编程中，每个Servlet也是单例。
11) 在Sping MVC框架/Struts1框架中，控制器对象也是单例。

单例模式的优点：

1)      由于单例模式只生成一个实例，减少了系统性能开销，但一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式解决。

2)      单例模式可以在系统设置全局的访问点，优化共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

Java中常见的五种单例模式实现方式：

1) 主要：
饿汉式(线程安全，调用效率高。但是，不能延时加载。)
懒汉式(线程安全，调用效率不高。但是，可以延时加载。)
2) 其他
双重检测锁式(由于JVM底层内部模型原因，偶尔会出问题。不建议使用)
静态内部类式(线程安全，调用效率高。但是，可以延时加载)
枚举单例(线程安全，调用效率高，不能延时加载，可以天然防止反射和序列化漏洞)

2.1 饿汉式单例模式源码

package com.bjsxt.singleton;

/**
 * 测试饿汉式单例模式
*/
public class SingletonDemo1 {
	
	//类初始化时，立即加载这个对象（没有延时加载的优势）。
        //加载类时，天然是线程安全的！
	private static SingletonDemo1 instance = new SingletonDemo1();  
	
	private SingletonDemo1(){
	}
	
	//方法没有同步，调用效率高！
	public static SingletonDemo1  getInstance(){
		return instance;
	}
	
}

饿汉式单例模式中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一个该类，肯定不会发生并发访问问题。因此，可以省略synchronized关键字。

 

问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！


2.2 懒汉式单例源码

package com.bjsxt.singleton;

/**
 * 测试懒汉式单例模式
 */
public class SingletonDemo2 implements Serializable {
	
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo2 instance;  
	
	private SingletonDemo2(){ //私有化构造器
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo2  getInstance(){
		if(instance==null){
			instance = new SingletonDemo2();
		}
		return instance;
	}
	
}
懒汉式实现(单例对象 延迟加载)：
要点：Lazy load! 延时加载，懒加载！真正用的时候才加载！
问题：资源利用效率高了。但是，每次调用getInstance()方法都要同步， 并发效率比较低。

2.3 双重检测锁式单例

package com.bjsxt.singleton;

/**
 * 双重检查锁实现单例模式
 */
public class SingletonDemo3 { 

  private static SingletonDemo3 instance = null; 

  public static SingletonDemo3 getInstance() { 
    if (instance == null) { 
      SingletonDemo3 sc; 
      synchronized (SingletonDemo3.class) { 
        sc = instance; 
        if (sc == null) { 
          synchronized (SingletonDemo3.class) { 
            if(sc == null) { 
              sc = new SingletonDemo3(); 
            } 
          } 
          instance = sc; 
        } 
      } 
    } 
    return instance; 
  } 

  private SingletonDemo3() { 

  } 
    
}

这个模式将同步内容下移到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次才同步创建了以后就没必要了。

 

问题：

由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题，不建议使用。

2.4 静态内部类实现单例

package com.bjsxt.singleton;

/**
 * 测试静态内部类实现单例模式
 * 这种方式：线程安全，调用效率高，并且实现了延时加载！
 */
public class SingletonDemo4 {
	
	private static class SingletonClassInstance {
		private static final SingletonDemo4 instance = new SingletonDemo4();
	}
	
	private SingletonDemo4(){
	}
	
	//方法没有同步，调用效率高！
	public static SingletonDemo4  getInstance(){
		return SingletonClassInstance.instance;
	}
	
}

静态内部类实现方式(也是一种懒加载方式)；

要点：

1)      外部类没有static属性，则不会像饿汉式那样立即加载对象；

2)      只有真正调用getInstance()，才会加载静态内部类。加载类时线程是安全的，instance是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全。

兼备了 并发高效调用和延迟加载的优势！

2.5 枚举类实现单例模式

package com.bjsxt.singleton;

/**
 * 测试枚举式实现单例模式(没有延时加载)
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public enum SingletonDemo5 {
	
	//这个枚举元素，本身就是单例对象！
	INSTANCE;
	
	//添加自己需要的操作！
	public boolean singletonOperation(){
		System.out.println("执行枚举中的方法。");
		return true;
	}
	
}
枚举单例测试类： 

package com.bjsxt.singleton;

public class TestSingletonEnum {

	public static void main(String[] args) {
		System.out.println(SingletonDemo5.INSTANCE.singletonOperation());
		//System.out.println(SingletonDemo5.INSTANCE == SingletonDemo5.INSTANCE);
	}

}
运行结果如下：

执行枚举中的方法。
true


优点：

①实现简单

②枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和序列化的漏洞创建新的对象！

缺点：

①无延时加载

2.6 测试五种创建单例模式的效率

测试代码如下： 

package com.bjsxt.singleton;

import java.util.concurrent.CountDownLatch;

/**
 * 测试多线程环境下五种创建单例模式的效率
 */
public class Client3 {
	
	public static void main(String[] args) throws Exception {
		
		long start = System.currentTimeMillis();
		int threadNum = 10;
		final CountDownLatch  countDownLatch 
			= new CountDownLatch(threadNum);
		
		for(int i=0;i<threadNum;i++){
			new Thread(new Runnable() {
				@Override
				public void run() {
					
					for(int i=0;i<1000000;i++){
					    //下面是创建对象的代码
//						Object o = SingletonDemo4.getInstance();
						Object o = SingletonDemo5.INSTANCE;
					}
					
					countDownLatch.countDown();
				}
			}).start();
		}
		
		//main线程阻塞，直到计数器变为0，才会继续往下执行！
		countDownLatch.await();	
		
		long end = System.currentTimeMillis();
		System.out.println("总耗时："+(end-start));
	}
}

常见的五种单例模式在线程环境下的效率测试：

大家只要关注相对值即可。在不同的环境下不同的程序测得的值完全不一样。

单例模式种类

时间

饿汉式

22ms

懒汉式

636ms

静态内部类

28ms

枚举式

32ms

双重检测锁

65ms

 

1、CountDownLatch

同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

①countdown()：当线程调用此方法，则计数减一(建议放在finally里执行);

②await()：调用此方法会一直阻塞当前线程，直到计数器的值为0。

 

使用myeclipse的UML插件画出类图，大家也可以使用：rational rose、metamill等。

 

如何选用？

单例对象占用资源少，不需要延时加载：枚举式好于饿汉式；

单例对象占用资源大，需要延时加载：静态内部类好于懒汉式。

 

问题：

反射可以破解上面几种(不包含枚举)方式！(可以在构造方法中手动抛出异常控制)；

反序列化可以破解上面几种方式！

可以通过定义readResolve()防止获得不同对象。反序列时，如果对象所在类定义了readResolve()，(实际是一种回调)，定义返回哪个对象。

2.7 单例模式的破解与防止破解

2.7.1 通过反射和反序列化破解单例

package com.bjsxt.singleton;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

/**
 * 测试反射和反序列化破解单例模式
*/
public class Client2 {
	
	public static void main(String[] args) throws Exception {
		SingletonDemo2 s1 = SingletonDemo2.getInstance();
		SingletonDemo2 s2 = SingletonDemo2.getInstance();
		
		System.out.println(s1);
		System.out.println(s2);
		
		//通过反射的方式直接调用私有构造器
//		Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("com.bjsxt.singleton.SingletonDemo6");
//		Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
//		c.setAccessible(true);
//		SingletonDemo6  s3 = c.newInstance();
//		SingletonDemo6  s4 = c.newInstance();
//		System.out.println(s3);
//		System.out.println(s4);
		
		//通过反序列化的方式构造多个对象 
		FileOutputStream fos = new FileOutputStream("d:/a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s1);
		oos.close();
		fos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
		SingletonDemo2 s3 =  (SingletonDemo2) ois.readObject();
		System.out.println(s3);
	}
}
运行结果(发序列化出来的对象地址与之前的不同)：

com.bjsxt.singleton.SingletonDemo2@15db9742
com.bjsxt.singleton.SingletonDemo2@15db9742
com.bjsxt.singleton.SingletonDemo2@33909752

2.7.2 防止反射和反序列化破解单例

修改后的懒汉式：

package com.bjsxt.singleton;

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 测试懒汉式单例模式(如何防止反射和反序列化漏洞)
 */
public class SingletonDemo6 implements Serializable {
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;  
	
	private SingletonDemo6(){ //私有化构造器
		if(instance!=null){
			throw new RuntimeException();
		}
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo6  getInstance(){
		if(instance==null){
			instance = new SingletonDemo6();
		}
		return instance;
	}
	
	//反序列化时，如果定义了readResolve()则
	//直接返回此方法指定的对象。而不需要单独再创建新对象！
	private Object readResolve() throws ObjectStreamException {
		return instance;
	}
	
}
测试类如下： 
package com.bjsxt.singleton;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

/**
 * 测试反射和反序列化破解单例模式
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public class Client2 {
	
	public static void main(String[] args) throws Exception {
		SingletonDemo6 s1 = SingletonDemo6.getInstance();
		SingletonDemo6 s2 = SingletonDemo6.getInstance();
		
		System.out.println(s1);
		System.out.println(s2);
		
		//通过反射的方式直接调用私有构造器
//		Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("com.bjsxt.singleton.SingletonDemo6");
//		Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
//		c.setAccessible(true);
//		SingletonDemo6  s3 = c.newInstance();
//		SingletonDemo6  s4 = c.newInstance();
//		System.out.println(s3);
//		System.out.println(s4);
		
		//通过反序列化的方式构造多个对象 
		FileOutputStream fos = new FileOutputStream("d:/a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s1);
		oos.close();
		fos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
		SingletonDemo6 s3 =  (SingletonDemo6) ois.readObject();
		System.out.println(s3);
		
	}
}
运行结果(反序列化出来的对象地址和之前的相同)：
com.bjsxt.singleton.SingletonDemo6@15db9742
com.bjsxt.singleton.SingletonDemo6@ 15db9742
com.bjsxt.singleton.SingletonDemo6@ 15db9742


Nazarite_KakaLuoTo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA设计模式之单例模式
09-22
JAVA设计模式之单例模式。 一篇文章带你快速了解！
单例模式（五种详解）
weixin_56902337的博客
05-22 1705
今天京东实习微信视频面试，让我手写一个熟悉的设计模式，那肯定写单例模式，我果断写了双重锁的懒汉式。HR又让我写出内部类的单例模式，之前看视频没讲过，自己一时也想不出来，面试官让我等会可以去看看。 我们常用的单例模式有五种： 饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式。 1.饿汉式 public class SingleTon1 { private static SingleTon1 instance = new SingleTon1(); private Sin
java中五种单例模式
张晓鉴Allen的博客
01-11 540
坚持每天写博文，记录开发中的点点滴滴 饿汉式 饿汉式 饿汉式可以说是我们最先接触单例模式的例子了，是最基本的单例写法，也是最快最懒的方式。 优点：简单好写；缺点：类加载就初始化了对象，影响应用启动速度 package singleton; /** * * @ClassName: BaseSingleton * @Description: TODO(饿汉式单例模式) * @author
五种单例模式
wgwg
04-28 96
单例模式: 单例模式是一个软件的设计模式，为了保证一个类，无论调用多少次产生的实例对象， 都是指向同一个内存地址，仅仅只有一个实例(对象)! 五种单例: - 模块 - 装饰器 - 元类 - __new__ - 类方法: classmethod class People: def __init__(self, name, age, sex): ...
设计模式——五种单例模式
长臂人猿的博客
01-28 807
前言 ​ 单例模式，简单的说就是：提供一个对外的公共方法来获取唯一的对象实例。 ​ 设计模式的精髓就是在于：找到变化，封装变化。 这里，我们使用五种方式实现单例模式： 懒汉模式 饿汉模式 双检锁 静态内部类 枚举类 懒汉模式 获取实例对象的时候才判定有没有生成对象，是为懒汉。 /** * @Author: cbry * @Description: 懒汉模式 ， 获取实例对象可能会有线程安全问题，是否线程安全可以加上 synchronized 关键字。 **/ public class Lazy
单例模式的五种方式
java知识整理
10-10 896
文章目录1、懒汉式（单例对象延迟加载）2、饿汉式（单例对象立即加载）3、双重校验锁（ DCL，即double-checked locking）4、静态内部类式5、枚举 根据B站尚学堂视频整理：https://www.bilibili.com/video/BV1F54y1R7L1?p=1 参考菜鸟教程：https://www.runoob.com/design-pattern/singleton-pattern.html 核心作用： 保证一个类只有一个实例，并且提供了一个访问该实例的全局访问点。 常见应用
二十三种设计模式Java版之单例模式
05-06
二十三种设计模式Java版之单例模式 单例模式博文地址：https://blog.csdn.net/program_highway/article/details/124485842
全面解析Java设计模式之单例模式
08-28
主要帮助大家全面解析Java设计模式之单例模式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java 设计模式之单例的实例详解
08-29
主要介绍了java 设计模式之单例的实例详解的相关资料,希望通过本文能帮助到大家，让大家彻底理解掌握单例模式，需要的朋友可以参考下
Java设计模式之单例模式及其应用
12-22
　二、单例模式的几种形式 　1. 饿汉式单例 public class Singleton { private static final Singleton singleton= new Singleton(); private Singleton(){ } public Singleton getSingleton(){ return sin
五种单例模式如何选择适合的
Nico的知识小站
07-08 1177
了解单例模式之前先理解一个概念：延时加载 延时加载是指只有当对象在真正使用的时候才会被加载到内存中创建实例，不使用时不会创建。从速度和反应时间角度来讲，非延迟加载（即饿汉式）好，从资源利用率上说，延迟加载（又称懒汉式）好 单例模式的实现方式有五种，如下所示： 主要： 饿汉式 - 线程安全，调用效率高，但是不支持延迟加载。 懒汉式 - 线程安全，调用效率不高，可以支持延时加载。 其他： ...
单例模式的五种写法
热门推荐
absolute_chen的博客
06-23 23万+
设计模式（Design pattern），提供了在软件开发过程中面临的一些问题的最佳解决方案，是Java开发者必修的一门课程。主要分创建型模式、结构型模式和行为型模式。其中接下来我们要写的是单例模式，属于创建型模式。 单例模式，顾名思义就是只有一个实例，并且她自己负责创建自己的对象，这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。下面我们来看下有哪几种实现方式吧...
常用的五种单例模式实现方式
HaoMeng_郝猛的博客
01-15 1万+
单例模式的关键点1) 构造方法不对外开放,为private2) 确保单例类只有一个对象,尤其是多线程模式下3) 通过静态方法或枚举返回单例对象4) 确保单例类在反序列化是不会重新创建新的对象 单例模式的实现方式1)  饿汉式public class Singleton1 {     /*     * 饿汉式是在声明的时候就已经初始化Singleton1,确保了对象的唯一性     *     *
单例模式SingletonPattern
Javaer`s blog
01-20 231
Java实现多种单例模式SingletonPattern 单例设计模式简介 保证某个类的实例只能被创建一次，以后都调用这个实例，保证了某个状态的一致性 常见的用到单例模式的情况有： windows下的任务管理器，只允许创建一个实例，否则同时打开多个任务管理器，这个里结束了某个进程，另外一个管理器中还可以看到，不是很安全； Android中的Application一般情况下都是只有一个，需要...
五种基本单例模式
qq_43949280的博客
01-29 1022
目录标题模式简介饿汉式懒汉式懒汉式(双重检验锁)静态内部类枚举类型 模式简介 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 许多时候整个系统只需要拥有一个的全
单例模式的五种实现方式
源码有毒的专栏
12-05 1万+
单例模式可以说是23中设计模式中应用最广的一种模式了。        定义：确保某一个类只有一个实例，自行实例化并且想整个系统提供这个实例。       使用场景：避免某个类产生多个对象而消耗过多的资源，确保某个类在程序中只有一个实例。比如我们使用的图片加载器ImageLoader。往往单例创建的对象，耗费的资源都比较多，所以在初始化单例对象的时候就显得尤为重要了，接下来，我们就来聊一聊
单例模式（Singleton）
weixin_34399060的博客
05-07 236
首先来明确一个问题，那就是在某些情况下，有些对象，我们只需要一个就可以了， 比如，一台计算机上可以连好几个打印机，但是这个计算机上的打印程序只能有一个， 这里就可以通过单例模式来避免两个打印作业同时输出到打印机中， 即在整个的打印过程中我只有一个打印程序的实例。 简单说来，单例模式（也叫单件模式）的作用就是保证在整个应用程序的生命周期中， ...
java设计模式单例模式
最新发布
03-14
单例模式是一种常用的设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在Java中，实现单例模式有多种方式，下面是两种常见的实现方式： 1. 饿汉式单例模式： 在类加载时就创建实例，保证了线程安全，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值