【学习课件】第二章单例模式练习
Java设计模式之《单例模式》及应用场景
Java设计模式之《单例模式》及应⽤场景所谓单例，指的就是单实例，有且仅有⼀个类实例，这个单例不应该由⼈来控制，⽽应该由代码来限制，强制单例。
单例有其独有的使⽤场景，⼀般是对于那些业务逻辑上限定不能多例只能单例的情况，例如：类似于计数器之类的存在，⼀般都需要使⽤⼀个实例来进⾏记录，若多例计数则会不准确。
其实单例就是那些很明显的使⽤场合，没有之前学习的那些模式所使⽤的复杂场景，只要你需要使⽤单例，那你就使⽤单例，简单易理解。
所以我认为有关单例模式的重点不在于场景，⽽在于如何使⽤。
1、常见的单例模式有两种创建⽅式：所谓饿懒汉式与饿汉式（1）懒汉式 何为懒？顾名思义，就是不做事，这⾥也是同义，懒汉式就是不在系统加载时就创建类的单例，⽽是在第⼀次使⽤实例的时候再创建。
详见下⽅代码⽰例：public class LHanDanli {//定义⼀个私有类变量来存放单例，私有的⽬的是指外部⽆法直接获取这个变量，⽽要使⽤提供的公共⽅法来获取private static LHanDanli dl = null;//定义私有构造器，表⽰只在类内部使⽤，亦指单例的实例只能在单例类内部创建private LHanDanli(){}//定义⼀个公共的公开的⽅法来返回该类的实例，由于是懒汉式，需要在第⼀次使⽤时⽣成实例，所以为了线程安全，使⽤synchronized关键字来确保只会⽣成单例public static synchronized LHanDanli getInstance(){if(dl == null){dl = new LHanDanli();}return dl;}}（2）饿汉式 ⼜何为饿？饿者，饥不择⾷；但凡有⾷，必急⾷之。
此处同义：在加载类的时候就会创建类的单例，并保存在类中。
详见下⽅代码⽰例：public class EHanDanli {//此处定义类变量实例并直接实例化，在类加载的时候就完成了实例化并保存在类中private static EHanDanli dl = new EHanDanli();//定义⽆参构造器，⽤于单例实例private EHanDanli(){}//定义公开⽅法，返回已创建的单例public static EHanDanli getInstance(){return dl;}}2、双重加锁机制 何为双重加锁机制？ 在懒汉式实现单例模式的代码中，有使⽤synchronized关键字来同步获取实例，保证单例的唯⼀性，但是上⾯的代码在每⼀次执⾏时都要进⾏同步和判断，⽆疑会拖慢速度，使⽤双重加锁机制正好可以解决这个问题：public class SLHanDanli {private static volatile SLHanDanli dl = null;private SLHanDanli(){}public static SLHanDanli getInstance(){if(dl == null){synchronized (SLHanDanli.class) {if(dl == null){dl = new SLHanDanli();}}}return dl;}}看了上⾯的代码，有没有感觉很⽆语，双重加锁难道不是需要两个synchronized进⾏加锁的吗？ ...... 其实不然，这⾥的双重指的的双重判断，⽽加锁单指那个synchronized，为什么要进⾏双重判断，其实很简单，第⼀重判断，如果单例已经存在，那么就不再需要进⾏同步操作，⽽是直接返回这个实例，如果没有创建，才会进⼊同步块，同步块的⽬的与之前相同，⽬的是为了防⽌有两个调⽤同时进⾏时，导致⽣成多个实例，有了同步块，每次只能有⼀个线程调⽤能访问同步块内容，当第⼀个抢到锁的调⽤获取了实例之后，这个实例就会被创建，之后的所有调⽤都不会进⼊同步块，直接在第⼀重判断就返回了单例。
TypeScript实现设计模式——单例模式
TypeScript实现设计模式——单例模式最近在学习设计模式，⼜正好刚上⼿了typescript，就想要⽤ts实现⼀下试试。
单例模式的⽬的是限制⼀个类只能被实例化⼀次，提供⼀个全局的访问点。
单例模式⼜被分为懒汉单例模式和饿汉单例模式，懒汉单例模式就是在第⼀次调⽤时实例化，饿汉单例模式是类加载时就实例化。
核⼼要点：把⼀个静态私有变量确⽴为唯⼀的实例，外部通过静态⽅法访问这个唯⼀的实例，并把构造函数设为私有。
懒汉单例模式class PeopleSingle {/**核⼼ - ⼀个接收实例的静态成员 */private static people: PeopleSingle;private name: string;/**核⼼ - 私有构造函数 */private constructor(name: string) { = name;}/**核⼼ - 获取实例 */public static getInstance(): PeopleSingle {if (this.people == null) {this.people = new PeopleSingle('⾦闪闪');}return PeopleSingle.people;}public say(): void {console.log(`I'm ${}.`);}}测试let people = PeopleSingle.getInstance();people.say();饿汉单例模式class PeopleSingle {/**核⼼ - ⼀个接收实例的静态成员，直接创建好实例 */private static people: PeopleSingle = new PeopleSingle('⾦闪闪');private name: string;/**核⼼ - 私有构造函数 */private constructor(name: string) { = name;}/**核⼼ - 获取实例 */public static getInstance(): PeopleSingle {return PeopleSingle.people;}public say(): void {console.log(`I'm ${}.`);}}测试let people = PeopleSingle.getInstance();people.say();举的例⼦不是特别好，但是意思是这个意思。
Java设计模式之（一）------单例模式
Java设计模式之（⼀）------单例模式1、什么是单例模式 采取⼀定的办法保证在整个软件系统中，确保对于某个类只能存在⼀个实例。
单例模式有如下三个特点： ①、单例类只能有⼀个实例 ②、单例类必须⾃⼰创建⾃⼰的实例 ③、单例类必须提供外界获取这个实例的⽅法2、单例类的设计思想（Singleton） ①、外界不能创建这个类的实例，那么必须将构造器私有化。
public class Singleton {//构造器私有化private Singleton(){}} ②、单例类必须⾃⼰创建⾃⼰的实例，不能允许在类的外部修改内部创建的实例。
⽐如将这个实例⽤ private 声明。
为了外界能访问到这个实例，我们还必须提供 get ⽅法得到这个实例。
因为外界不能 new 这个类，所以我们必须⽤ static 来修饰字段和⽅法。
//在类的内部⾃⼰创建实例private static Singleton singleton = new Singleton();//提供get ⽅法以供外界获取单例public Singleton getInstance(){ return singleton;} ③、是否⽀持延迟加载？ 有些情况下，创建某个实例耗时长，占⽤资源多，⽤的时候也少，我们会考虑在⽤到的时候才会去创建，这就是延迟加载。
但有些情况，按照 fail-fast 的设计原则（有问题及早暴露），⽐如某个实例占⽤资源很多，如果延迟加载，会在程序运⾏⼀段时间后OOM，如果在程序启动的时候就创建这个实例，我们就可以⽴即去修复，不会导致程序运⾏之后的系统奔溃。
所以，是否⽀持延迟加载需要结合实际情况考虑。
④、保证线程安全 这个是⼀定要考虑的，如果你写的单例类存在线程安全问题，那就是伪单例了。
3、单例类的⼏种实现⽅式3.1 单例模式之饿汉模式public class Singleton {//构造器私有化private Singleton(){}//在类的内部⾃⼰创建实例private static Singleton singleton = new Singleton();//提供get ⽅法以供外界获取单例public static Singleton getInstance(){return singleton;}} 测试：public static void main(String[] args) {Singleton s1 = Singleton.getInstance();Singleton s2 = Singleton.getInstance();System.out.println(s1.equals(s2)); //true} 这种模式在类加载的时候实例 singleton 就已经创建并初始化好了，所以是线程安全的。
设计模式学习——单例模式
设计模式学习——单例模式⼀、介绍单例模式（Singleton Pattern）是 Java 中最简单的设计模式之⼀。
这种类型的设计模式属于创建型模式，它提供了⼀种创建对象的最佳⽅式。
这种模式涉及到⼀个单⼀的类，该类负责创建⾃⼰的对象，同时确保只有单个对象被创建。
这个类提供了⼀种访问其唯⼀的对象的⽅式，可以直接访问，不需要实例化该类的对象。
⼆、单例模式⼏种实现1）饿汉式（推荐）饿汉式是最简单的单例实现形式，并且具备线程安全特性（由classloader机制保障线程安全），唯⼀的不⾜就是不管程序中有没有⽤到此对象都会被加载进内存，当然个⼈认为这个缺点影响不⼤，毕竟如果你都压根不⽤此对象了那⼲嘛还要加载呢。
public class DemoManager {private static DemoManager INSTANCE = new DemoManager();private DemoManager() {}public static DemoManager getInstance() {return INSTANCE;}}2）懒汉式懒汉式顾名思义只有在需要的时候加载，懒汉式也有⼏种写法：线程不安全版本（不推荐）public class DemoManager {private static DemoManager demoManager;private DemoManager() {}public static DemoManager getInstance() {if (demoManager == null) {demoManager = new DemoManager();}return demoManager;}}线程安全版本（不推荐）public class DemoManager {private static DemoManager demoManager;private DemoManager() {}public static synchronized DemoManager getInstance() {if (demoManager == null) {demoManager = new DemoManager();}return demoManager;}}虽然此版本通过加锁保障了线程安全，但是我们知道加锁是⽐较消耗资源的操作，在⾼并发场景下会存在性能问题，因此此版本也不推荐。
创建型-单例（Singleton）模式
创建型-单例（Singleton）模式 单例模式属于创建型模式的⼀种，创建型模式是⼀类最常⽤的设计模式，在软件开发中应⽤⾮常⼴泛。
创建型模式将对象的创建和使⽤分离，在使⽤对象时⽆需关⼼对象的创建细节，从⽽降低系统的耦合度，让设计⽅案更易于修改和扩展。
每⼀个创建型模式都在视图回答3个问题：3W -> 创建什么（What）、由谁创建（Who）和何时创建（When）。
本篇是创建型模式的第⼀篇，也是最简单的⼀个设计模式，虽然简单，但是其使⽤频率确是很⾼的。
单例模式（Singleton）学习难度：★☆☆☆☆使⽤频率：★★★★☆⼀、单例模式的动机 相信⼤家都使⽤过Windows任务管理器，我们可以做⼀个尝试：在Windows任务栏的右键菜单上多次点击“启动任务管理器”，看能否打开多个任务管理器窗⼝。
正常情况下，⽆论我们启动多少次，Windows系统始终只能弹出⼀个任务管理器窗⼝。
也就是说，在⼀个Windows 系统中，任务管理器存在唯⼀性。
在实际开发中，我们经常也会遇到类似的情况，为了节约系统资源，有时候需要确保系统中某个类只有唯⼀⼀个实例，当这个唯⼀实例创建成功之后，⽆法再创建⼀个同类型的其他对象，所有的操作都只能基于这个唯⼀实例。
为了确保对象的唯⼀性，可以通过创建单例模式来实现，这也就是单例模式的动机所在。
⼆、单例模式概述2.1 要点单例（Singleton）模式：确保某⼀个类只有⼀个实例，⽽且⾃⾏实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的⽅法。
单例模式是⼀种对象创建模式。
单例模式有3个要点：某个类只能有⼀个实例它必须⾃⾏创建这个实例它必须⾃⾏向整个系统提供这个实例 2.2 结构图 从上图中可以看出，单例模式结构图中只包含了⼀个单例的⾓⾊。
Singleton（单例）：在单例类的内部实现只⽣成⼀个实例，同时它提供⼀个静态的GetInstance()⽅法，让客户可以访问它的唯⼀实例；为了防⽌在外部对单例类实例化，它的构造函数被设为private；在单例类的内部定义了⼀个Singleton类型的静态对象，作为提供外部共享的唯⼀实例。
Java 设计模式练习题及答案
Java 设计模式练习题及答案在学习Java设计模式时，练习题是非常重要的一部分。
通过练习题的实践，可以更好地理解和应用设计模式，提升自己的编程能力。
本文将介绍一些Java设计模式练习题，并提供相应的答案，希望能对读者在设计模式的学习和实践中有所帮助。
一、题目一：单例模式——懒汉式实现问题描述：请编写一个线程安全的懒汉式单例模式。
解答示例：```javapublic class Singleton {private static Singleton instance;private Singleton() {}public static synchronized Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}}```二、题目二：工厂模式——简单工厂实现问题描述：请使用简单工厂模式实现一个计算器，支持加减乘除四种运算。
解答示例：```javapublic class CalculatorFactory {public static Calculator createCalculator(String operator) {Calculator calculator = null;switch (operator) {case "+":calculator = new AddCalculator();break;case "-":calculator = new SubtractCalculator();break;case "*":calculator = new MultiplyCalculator();break;case "/":calculator = new DivideCalculator();break;}return calculator;}}public interface Calculator {double calculate(double num1, double num2);}public class AddCalculator implements Calculator {@Overridepublic double calculate(double num1, double num2) { return num1 + num2;}}public class SubtractCalculator implements Calculator { @Overridepublic double calculate(double num1, double num2) {return num1 - num2;}}// MultiplyCalculator和DivideCalculator类似，省略代码// 使用示例Calculator calculator = CalculatorFactory.createCalculator("+");double result = calculator.calculate(2, 3); // 结果为5```三、题目三：观察者模式问题描述：请设计一个简单的气象站系统，该系统需要实现以下功能：1. 可以添加观察者并实时更新气象数据；2. 当气象数据发生变化时，自动通知所有观察者进行更新。
设计模式——06原型模式、单例模式与建造者模式
原型模式（续）
模式结构
Client
+ operation () prototype
Prototype
+ clone () : Prototype
p=prototype.clone();
ConcretePrototypeA
+ clone () : Prototype
ConcretePrototypeB
MotorBuilder
<<Constructor>> <<Override>> <<Override>> <<Override>> <<Override>> MotorBuilder () buildFrame () buildEngine () buildWheels () buildDoors ()
原型模式（续）
模式解释 深克隆与浅克隆
原型模式（续）
实例分析 实例一：孙悟空变身（浅克隆）
<<Unresolved Interface>>
Cloneable
GoldRingedStaff
staff
Monkey
- staff : GoldRingedStaff = null + <<Constructor>> Monkey () + clone () : Object + getGoldRingedStaff () : GoldRingedStaff
单例模式（续）
模式使用 在以下情况下可以使用单例模式：
系统只需要一个实例对象。
跟我学GOF设计模式——单例模式
（2）利用数据访问服务组件进行隔离，此时的数据访问服 务组件为门面组件
（3）但门面组件应该为单例类 ----产生“一夫当关、万夫莫关”的效果
9、将某系统中的XML解析组件设计为单例 （1）为什么要设计为单例----XML IO访问应该为单例方式 （2）添加XMLParseBean单例类
4、单例对象和全局对象在应用方面的不同 （1）对全局对象的使用 一般在程序开始运行时初始化这个全局变量，代码 中每一个使用该类的地方都引用这个全局变量。 （2）全局对象缺点 在应用中的某个流程执行过程中，实际上会有些对初始化，而且初始化也需要花点时间。 没有办法做到延迟加载
（3）使用单例对象 将类的单一实例以及类初始化的职责封装起来，然 后提供一个全局的访问点让其他的代码能够访问到这个单 一的类的实例-----具体请见前面的实现代码。
5、应用单例模式会有哪些代价 （1）首先实现单例模式类的“单例”特性是不能被子类天 然继承的 因为私有变量instance和公共方法getInstance () 都是静态的----请见前面的代码，而且基类的构造函数是 private的。 （2）另外一点就是不透明----要求采用单例对象中的某方 法来获得 调用者自己要知道在使用一个单例类单例的对象， 需要通过单例对象中的 那个方法来获得单例对象的实例----开发者需要提供API说明。 （3）为了保证单例类能够真正只产生出一个对象实例 可能需要在实现的代码中要应用线程同步机制、甚至 要采用双重检查锁定的“双重同步”——而每执行一次 同步代码，系统都要付出高昂的性能代价
（2）单例模式通常的实现形式之一
（3）Singleton模式通常的实现形式之二
注意单例类中的 getInstance方法应 该加synchronized限 定
第二章 单例模式练习.
class TestTrafficLight { public static void main(String[] args) { TrafficLight red = TrafficLight.getLight("red"); System.out.println(red); TrafficLight green = TrafficLight.getLight(“green"); System.out.println(green); TrafficLight yellow = TrafficLight.getLight(“yellow"); System.out.println(yellow);
计算机科学与工程学院 No.3/10
public class GenerateID UML与设计模式 第1章 OO方法概述 { private static GenerateID singleton ; private GenerateID(){} public synchronized static GenerateID getInstance(){ if (singleton == null) { singleton = = new GenerateID(); } return singleton; } private long currentID=1000; public long getID(){ return currentID++; } } class TestID { public static void main(String args[]){ GenerateID g1 = GenerateID.getInstance(); GenerateID g2 = GenerateID.getInstance(); System.out.println(g1.getID()); System.out.println(g2.getID()); Singleton System.out.println(g1.getID()); System.out.println(g2.getID()); 代码示例 } }
单例模式讲解
• • • • • • • • • • • • • • • • • • •
package test; /** * 多线程同步。单例 */ import com.student.Student; public class Test { public static void main(String[] args) { Student stu=Student.getInstance(); Student stu2=Student.getInstance(); Student stu3=Student.getInstance(); ="张力"; ="王五"; ="香梅"; System.out.println(); System.out.println(); System.out.println(); } }
为什么要用单例模式
• 现实生活中或者实际开发中通常会遇到一些多资源管理的 问题 • 例如:在计算机系统中，需要管理的资源包括软件外部资源， • 管 资 括软件内 资 ， ， 每台计算机可以有若干个打印机，但只能有一个 数 软件 个（ 个）属 （properties） 件 系统 • Printer Spooler， 以避免两个打印作业同时输出到打印 。这样 系统应当 个对 来管 个属 件。 机中。每台计算机可以有若干传真卡，但是只应该有一个 • 管 软件内 资 括 负责记录网 来访 软件负责管理传真卡，以避免出现两份传真作业同时传到 数 件，记录软件系统内 件、 错 件， 传真卡中的情况。每台计算机可以有若干通信端口，系统 对系统 现进 检查 件 。这 件 须 应当集中管理这些通信端口，以避免一个通信端口同时被 管 ， 可 头。 两个请求同时调用。
我的讲解到此结束
JAVA设计模式之单例模式(网上搜集整理版)
JAVA设计模式之单例模式一、单例模式的介绍Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点。
全局对象和Singleton模式有本质的区别，因为大量使用全局对象会使得程序质量降低，而且有些编程语言根本不支持全局变量。
最重要的是传统的全局对象并不能阻止一个类被实例化多次。
Effecttive Java第二版中最新单例模式从Java 1.5发行版本起，实现Singleton的方法只需编写一个包含单个元素的枚举类型：// Enum singleton - the preferred approach - page 18public enum Elvis {INSTANCE;public void leaveTheBuilding() {System.out.println("Whoa baby, I'm outta here!");}// This code would normally appear outside the class!public static void main(String[] args) {Elvis elvis = Elvis.INSTANCE;elvis.leaveTheBuilding();}}这种方法在功能上与公有域方法相近，但是它更加简洁，无偿地提供了序列化机制，绝对防止多次实例化，即使是在面对复杂的序列化或者反射攻击的时候。
虽然这种方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法单例类只能有一个实例单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。
三、单例模式的应用每台计算机可以由若干个打印机，但只能有一个Printer Spooler，避免有两个作业同时输出到打印机。
一个具有自动编号主键的表可以有多个用户同时使用，但数据库中只能有一个地方分配下一个主键。
（转）单例模式超全整理（面试中常见的题目）
（转）单例模式超全整理（⾯试中常见的题⽬）单例模式虽然简单，却是⾯试中经常出现的⼀类问题。
1 单例模式单例模式的特点：⼀是某个类只能有⼀个实例⼆是它必须⾃⾏创建这个实例三是它必须⾃⾏向整个系统提供这个实例应⽤情况：对于多个对象使⽤同⼀个配置信息时，就需要保证该对象的唯⼀性。
如何保证对象的唯⼀性？⼀不允许其他程序⽤new创建该类对象。
⼆在该类创建⼀个本类实例三对外提供⼀个⽅法让其他程序可以获取该对象实现的⽅法：⼀是构造函数私有化⼆是类定义中含有⼀个该类的静态私有对象三是该类提供了⼀个静态的公共的函数⽤于创建或获取它本⾝的静态私有对象⽅法⼀饿汉式public class Person1 {//定义该类的静态私有对象private static final Person1 person1 =new Person1();//构造函数私有化private Person1(){}；//⼀个静态的公共的函数⽤于创建或获取它本⾝的静态私有对象public static Person1 getPerson1() {return person1;}}该⽅法虽然在多线程下也能正确运⾏但是不能实现延迟加载（）资源效率不⾼，可能getPerson1()永远不会执⾏到，但执⾏该类的其他静态⽅法或者加载了该类（class.forName)，那么这个实例仍然初始化⽅法⼆懒汉式public class Person1 {private static Person1 person1 =null;private Person1(){}public static Person1 getPerson1() {if(person1==null){person1=new Person1();}return person1;}}该⽅法只能在单线程下运⾏，当在多线程下运⾏时可能会出现创建多个实例的情况。
对该⽅法可以进⾏优化懒汉式（优化⼀）public class Person1 {private static Person1 person1 =null;private Person1(){}public static synchronized Person1 getPerson1() {if(person1==null){person1=new Person1();}return person1;}}该⽅法虽然能保证多线程下正常运⾏，但是效率很低，因为 person1=new Person1(); 这句话在整个程序运⾏中只执⾏⼀次，但是所有调⽤getPerson1的线程都要进⾏同步，这样会⼤⼤减慢程序的运⾏效率。
Java初级_单例设计模式
Java初级_单例设计模式单例模式：要点：1，某个类只能有⼀个实例2，必须⾃⾏创建实例3，必须⾃⾏向整个系统提供这个实例。
实现1，只提供私有的构造⽅法2，含有⼀个该类的静态私有对象3，提供⼀个静态的共有⽅法⽤于创建，获取静态私有对象。
代码实现⽅案1，饿汉式--对象创建过程中实例化2，懒汉式--静态共有⽅法中实例化，⽤到的时候才进⾏实例化操作。
单例模式的实现必须满⾜（ACD）个条件。
（选择三项）A类中的构造⽅法的访问权限必须设置为私有的B类中的构造⽅法必须⽤protected修饰C必须在类中创建该类的静态私有对象D在类中提供⼀个公有的静态⽅法⽤于创建、获取静态私有对象饿汉式:特点，创建对象实例的时候直接初始化。
class SingletonOne {// 1创建类中私有构造private SingletonOne() {}// 外部不能创建该实例// 2创建该类型的私有静态实例private static SingletonOne instance = new SingletonOne();// 3创建共有静态⽅法，返回静态实例对象。
public static SingletonOne getInstance() {return instance;}}public class Re {public static void main(String[] args) {SingletonOne one = SingletonOne.getInstance();SingletonOne two = SingletonOne.getInstance();System.out.println(one);System.out.println(two);// 验证结果，两个对象的应⽤表⽰相同，验证成功。
// 空间换时间。
}}编程练习某公司研发星球维护系统，请使⽤饿汉式单例模式的实现思想，设计编写地球类。
程序运⾏参考效果图如下：任务实现步骤：Earth类 定义私有构造⽅法，并在构造⽅法中打印输出“地球诞⽣” 结合饿汉模式，完成单例对象定义，实例化及静态⽅法设置测试类 结合已有输出提⽰、运⾏效果图完成对象实例创建及对⽐（具体对象引⽤信息不限）public class Earth {//定义私有构造⽅法，并在构造⽅法中打印输出“地球诞⽣”//定义私有静态类对象并完成实例化//定义公有静态⽅法返回类内的私有静态对象}public class Test {public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println("第⼀个地球创建中。