设计模式-单例模式 JAVA语言实现 (Head First 设计模式)

最新推荐文章于 2021-02-27 19:28:42 发布
最新推荐文章于 2021-02-27 19:28:42 发布
阅读量479 收藏 2
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 单例模式 first head 设计模式 java设计模式 多线程/反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39554102/article/details/85240400
版权

文章目录

单列模式

简述:

定义： 确保一个类只有一个实例,并提供一个全局访问点;

类图：
在这里插入图片描述

定义 和 类图 参考 《Head First 设计模式》

一、 懒汉单列 (延迟实例化)

1. 非线程安全的单列模式 (非同步)

@SuppressWarnings("serial")
public class Singleton implements Serializable {

	/**
	 * 静态的实例变量
	 */
	private static Singleton instance;
	
	/**
	 * 私有的构造方法
	 */
	private Singleton() {
		
	}
	
	public static Singleton instance() {
		
		if (instance == null) {
			instance = new Singleton();
		}
		
		return instance;
	}
}

测试代码
在单线程下的获取实例

public class SingletonTest {
	@Test
	public void test() {
		System.out.println(Singleton.instance());
		System.out.println(Singleton.instance());
		System.out.println(Singleton.instance());
		System.out.println(Singleton.instance());
	}
}

输出结果

test.Singleton@23e028a9
test.Singleton@23e028a9
test.Singleton@23e028a9
test.Singleton@23e028a9

多线程下获取实例:

	@Test
	public void test2() {
		// 无参无返回值的 lambda 表达式
		Runnable r = ()-> System.out.println(Thread.currentThread().getName() + " : " + Singleton.instance());
		Thread t1 = new Thread(r, "single-1");
		Thread t2 = new Thread(r, "single-2");
		Thread t3 = new Thread(r, "single-3");
		Thread t4 = new Thread(r, "single-4");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

输出结果:
这里的测试test2() 多执行几次就会出现不一致的实例

single-1 : test.Singleton@1c89e366
single-4 : test.Singleton@41b4086e
single-2 : test.Singleton@41b4086e
single-3 : test.Singleton@41b4086e

2.线程安全的单列模式(同步)

加了同步代码块的单列模式
关键代码块

synchronized(Singleton.class) {
	......
}

第一个版本的同步模式:

	public static synchronized Singleton instance() {
		if (instance == null) {
			instance = new Singleton();
		}
		return instance;
	}

版本二


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

在执行测试代码test2()
实例一致(同步),但是效率下降了…

single-4 : test.Singleton@41b4086e
single-2 : test.Singleton@41b4086e
single-3 : test.Singleton@41b4086e
single-1 : test.Singleton@41b4086e

优化版本一 的同步模式

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

测试结果:
这个代码无法同步

single-3 : test.Singleton@41b4086e
single-2 : test.Singleton@273d407a
single-1 : test.Singleton@273d407a
single-4 : test.Singleton@273d407a

优化版本二 的同步模式
这里的代码在 sync 关键字里多加了if 语句, 这是大名鼎鼎的 (双重锁) double-checked locking

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

测试结果:

single-1 : test.Singleton@7e8cd9b3
single-4 : test.Singleton@7e8cd9b3
single-2 : test.Singleton@7e8cd9b3
single-3 : test.Singleton@7e8cd9b3

为什么优化版本一无法同步?
在这里插入图片描述
假若现在有四个线程调用了 instance() 方法, 在还没有调用 new Singleton() 时, instance == null 是成立的;

二、饿汉单列模式 (加载实例化)

这段代码没什么好讲的, 加载时就实例化.不存在线程安全的问题;

@SuppressWarnings("serial")
public class Singleton implements Serializable {

	/**
	 * 静态的实例变量
	 */
	private static Singleton instance = new Singleton();
	
	/**
	 * 私有的构造方法
	 */
	private Singleton() {
		
	}
	
	public static Singleton instance() {
		return instance;
	}
}

三、反序列化 与 反射获取实例 (破坏单例模式)

1 . 序列化 与 反序列化

这段代码摘自 spring 源码 org.springframework.util.SerializationUtils

测试前代码准备
序列化与反序列化工具类

/*--------------------- serialize util ----------------------*/
public abstract class SerializableUtil {
	
	/**
	 * 序列化
	 * @param object
	 * @return
	 */
	public static byte[] serialize(Object object) {
		if (object == null) {
			return null;
		}
		ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
		try {
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.writeObject(object);
			oos.flush();
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Failed to serialize object of type: " + object.getClass(), ex);
		}
		return baos.toByteArray();
	}
	
	/**
	 * 返序列化
	 * @param bytes
	 * @return
	 */
	public static Object deserialize(byte[] bytes) {
		if (bytes == null) {
			return null;
		}
		try {
			ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
			return ois.readObject();
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Failed to deserialize object", ex);
		}
		catch (ClassNotFoundException ex) {
			throw new IllegalStateException("Failed to deserialize object type", ex);
		}
	}
}

测试代码:
反序列化获取实例, 破坏单例模式

	@Test
	public void test3() {
		Singleton singleton = Singleton.instance();
		System.out.println(singleton);
		
		byte[] b = SerializableUtil.serialize(singleton);
		Singleton s2 = (Singleton) SerializableUtil.deserialize(b);
		System.out.println(s2);
		System.out.println(s2 == singleton);
	}

测试结果:

test.Singleton@23e028a9
test.Singleton@2758fe70
s2 == singleton : false

防止反序列化破坏代理模式: 在Singleton 类里添加代码
关键代码

    private Object readResolve() {
        return instance();
    }

@SuppressWarnings("serial")
public class Singleton implements Serializable {

	.......省略

    private Object readResolve() {
        return instance();
    }
}

再此测试:

test.Singleton@23e028a9
test.Singleton@23e028a9
s2 == singleton : true

2.反射调用构造方法获取实例 (通过反射破坏单例模式)

测试代码:

	@Test
	public void test4() {
		Singleton singleton = Singleton.instance();
		System.out.println(singleton);
		
		Class<?> clazz = Singleton.class;
		Singleton s2 = null;
		try {
			Constructor<?> constructor = clazz.getDeclaredConstructor();
			constructor.setAccessible(true);
			Object obj = constructor.newInstance();
			if (obj instanceof Singleton) {
				s2 = (Singleton) obj;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(s2);
		System.out.println("s2 == singleton : " + (s2 == singleton));
		
	}

测试结果:出现多个实例

test.Singleton@23e028a9
test.Singleton@3dd4520b
s2 == singleton : false

防止反射破坏单列模式: 在构造方法中添加代码

关键代码

	/**
	 * 私有的构造方法
	 */
	private Singleton() {
		if (instance != null) {
			throw new RuntimeException("not null instance...");
		}
	}

再次测试:
在这里插入图片描述
(完结…)

还有克隆也可以出现多个实例, 但是这是不现实的

	@Test
	public void test5() {
		Singleton singleton = Singleton.instance();
		try {
			Singleton s2 = (Singleton) singleton.clone();
			System.out.println(s2 == singleton);
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}

完整代码

测试代码在 JDK 1.8 / eclipse / JUnit 5,环境下运行

package test;

import java.io.Serializable;

@SuppressWarnings("serial")
public class Singleton implements Serializable, Cloneable {

	/**
	 * 静态的实例变量
	 */
	private static Singleton instance;
	
	/**
	 * 私有的构造方法
	 */
	private Singleton() {
		if (instance != null) {
			throw new RuntimeException("not null instance...");
		}
	}
	
	public static Singleton instance() {
		if (instance == null) {
			synchronized(Singleton.class) {
				if (instance == null) {
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
	
    private Object readResolve() {

        return instance();

    }

	@Override
	public Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
    
    
}


public class SingletonTest {
	@Test
	public void test() {
		System.out.println(Singleton.instance());
		System.out.println(Singleton.instance());
		System.out.println(Singleton.instance());
		System.out.println(Singleton.instance());
	}
	
	@Test
	public void test2() {
		// 无参无返回值的 lambda 表达式
		Runnable r = ()-> System.out.println(Thread.currentThread().getName() + " : " + Singleton.instance());
		Thread t1 = new Thread(r, "single-1");
		Thread t2 = new Thread(r, "single-2");
		Thread t3 = new Thread(r, "single-3");
		Thread t4 = new Thread(r, "single-4");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
	
	@Test
	public void test3() {
		Singleton singleton = Singleton.instance();
		System.out.println(singleton);
		
		byte[] b = SerializableUtil.serialize(singleton);
		Singleton s2 = (Singleton) SerializableUtil.deserialize(b);
		System.out.println(s2);
		System.out.println("s2 == singleton : " + (s2 == singleton));
	}
	
	@Test
	public void test4() {
		Singleton singleton = Singleton.instance();
		System.out.println(singleton);
		
		Class<?> clazz = Singleton.class;
		Singleton s2 = null;
		try {
			Constructor<?> constructor = clazz.getDeclaredConstructor();
			constructor.setAccessible(true);
			Object obj = constructor.newInstance();
			if (obj instanceof Singleton) {
				s2 = (Singleton) obj;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(s2);
		System.out.println("s2 == singleton : " + (s2 == singleton));
		
	}
	
	@Test
	public void test5() {
		Singleton singleton = Singleton.instance();
		try {
			Singleton s2 = (Singleton) singleton.clone();
			System.out.println(s2 == singleton);
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}
}

喜欢的请点赞… ?

程序猿_JOJO
关注
专栏目录
java 设计模式 head first_Head First 设计模式系列之一----模板模式（java版）
weixin_42511338的博客
02-15 193
开篇序言：四人帮的设计模式对于我这个菜鸟看着打瞌睡，后面果断买了一本head first的，感觉还可以像看报纸似的，花了一个寒假的晚上看了大半，确实内容也挺吸引人的，讲的很风趣。否则我也不可能，大过年的小伙伴们还在外面耍，自己还在那里装B。可是看完的困惑也随之而来，我怎么才能熟练的操练这些模式呢！书上讲的头头是道，可是实际中我们确不知道怎么运用！后面看到别人牛逼的都是随便一个模式都能脱口面而出，还...
java设计模式源码-head-first-design-patterns-Java:HeadFirst设计模式源码JAVA版
05-19
First设计模式 Java 版源码 ​ 设计原则 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 针对接口编程，而不是针对实现编程。 多用组合，少用继承。 为了交互对象之间的松耦合...
Head First Java设计模式（高清中文完整版+附书源码）
03-30
这是高清Head First Java的电子书PDF，附加源码
head first 设计模式 java_吐血整理：Head First设计模式大全
weixin_42579969的博客
02-21 1081
1.策略模式：链接：http://www.imooc.com/article/11475题例：鸭子原则：1：找出应用中可能需要变化之处，把它们独立起来，不要和那些不需要变化。2：针对接口编程，而不是针对实现编程。3：多用组合，少用继承。策略模式定义了算法族，分别封装起来，让他们之间可以互相替换， 此模式让算法的变化独立于使用算法的客户。2.观察者模式：链接：http://www.imooc.com...
[Head First设计模式]策略模式
weixin_34025051的博客
01-28 141
系列文章 [Head First设计模式]山西面馆中的设计模式——装饰者模式 [Head First设计模式]山西面馆中的设计模式——观察者模式 [Head First设计模式]山西面馆中的设计模式——建造者模式 [Head First设计模式]饺子馆(冬至)中的设计模式——工厂模式 [Head First设计模式]一个人的平安夜——单例模式 [Head First设计模式]抢...
java单例设计模式
专栏
04-08 2649
单例设计模式
基于Java语言的《Head First 设计模式》学习笔记及实战练习源码
最新发布
09-27
本项目为《Head First 设计模式》的Java语言学习笔记与实战练习源码集合，包含104个文件，主要包括88个Java源文件、12个Markdown文档、3个XML配置文件及少量其他辅助文件。内容涵盖设计模式的学习笔记以及相应的代码...
Head First 设计模式 +Java设计模式(第2版)
10-17
《Java设计模式(第2版)》则更侧重于Java语言实现的设计模式，它涵盖了GoF模式的实现细节，同时可能还会涉及一些Java特有的模式，如枚举单例、注解驱动的设计模式等。此书可能会对每种模式进行深入探讨，包括其优缺点...
First Head Java+First Head 设计模式
04-08
《Head First Java》是本完整的面向对象（object-oriented，OO）程序设计和Java的学习指导。此书是根据学习理论所设计的，让你可以从学习程序语言的基础开始一直到包括线程、网络与分布式程序等项目。最重要的，你会...
head first 设计模式-C++实现.zip
01-23
《Head First 设计模式》是一本非常受欢迎的设计模式学习书籍，它通过直观、生动的方式讲解了23种经典的GOF设计模式。这本书原本是用Java语言来解释这些模式的，但这里我们有一个C++实现的版本，这为C++开发者提供了...
HeadFirst设计模式JAVA版源码
01-25
HeadFirst设计模式JAVA版源码
Head First 设计模式 源代码
04-23
Head First 设计模式中的源代码. 从官网下载, 可以方便学习.
Head First设计模式和HeadFirst in java 源码以及23种设计模式关系图
09-13
设计模式和java的源码，以及23中经典设计模式关系图。
java基础-head first 设计模式
gghh2015的博客
10-31 522
1、第一个设计原则：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 解释：如果每次新的需求一来，都会是某方面的代码发生变化，那么你就可以确定，这部分的代码需要被抽出来，和其他稳定的代码有所区分。 或是：把变化的部分取出来封装起来，以变以后可以轻易的改动或扩充此部分，而不影响不需要变化的其他部分。 总之：这几乎是每个设计模式背后的精神所在。
Head First 设计模式之单例模式(Java例子)
awake_lqh的博客
04-21 250
前言： 来源于《head first 设计模式》。当作读书笔记了，这次看的是第五章装单例模式。连续看了两章，下一章预告命令模式。单例模式看着简单，但其中的道理并不少。 单例模式的概念 用于确保一个类只有一个实例，并提供全局访问点。 由于过于简单吧，跳过日常举例子的环节，直接写出一步步演变的单例模式 经典单例模式 public class Singleton { private static ...
Headfirst java设计模式-状态模式
MoonShinesOnMyWay的博客
08-06 336
状态模式：封装基于状态的行为，并将行为委托到当前状态。 代码实现： (1)定义一个糖果机状态接口 public interface State { /** * insert quarter */ void insertQuarter(); /** * eject quarter */ void ejectQuarter...
Head First 设计模式之模版方法模式(Java例子)
awake_lqh的博客
04-22 160
前言： 来源于《head first 设计模式》。当作读书笔记了，这次看的是第8章模版方法模式。难顶呀每晚看完书，第二天早上总结。理解到了以前学习java、spring中的一些基础的概念，蛮有用的，希望自己可以一直坚持下去吧。 模版方法模式的概念 在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模版方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤 适配器模式的uml...
headfirst设计模式 不懂java看的懂吗_看完《HeadFirst设计模式》的一点想法(一)
weixin_28720573的博客
02-27 266
两个星期刷完这本设计模式的入门书，感触良多，不得不感叹模式的力量以及先人的智慧，本学期选修的Android课程中许多不明白的东西就渐渐地明白了。做点笔记，也算对于自己所学东西地一点总结。策咯模式特点：定义算法族，并进行封装，使其可以互相替换多用组合，少用继承针对接口编程，不针对实现编程参照书上的例子：// 封装行为的接口public interface FlyBehavior{void fly()...
设计模式之—单例模式(Singleton)-Java实现
迷失的小书童
01-08 788
单例模式限制了使用这个模式的类只能生成一个对象。有一些对象其实我们完全只需要一个即可，如：线程池（threadpool）、缓存（cache）、注册表（registry)的对象、设备的驱动程序的对象等等。事实上，这些类的对象只能有一个实例，如果制造出多个实例，就会导致许多问题的产生，例如：程序的行为异常、资源的过量使用、产生不一致的结果等等。Java Singleton模式就为我们提供了这样实现
Head First 设计模式：Java版入门经典
"设计模式java （ head first）" 这本书是关于设计模式的，特别是针对Java编程语言的。"Head First"系列以其独特的、易于理解的教学方式而闻名，这本《设计模式：Java版》也不例外，它被认为是介绍设计模式的经典之...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值