java设计模式——单例模式

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

单例设计模式介绍

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例， 并且该类只提供一个取得其对象实例的方法(静态方法)。
比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是 轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。

单例模式八种实现方式

  1. 饿汉式(静态常量)
  2. 饿汉式（静态代码块）
  3. 懒汉式(线程不安全)
  4. 懒汉式(线程安全，同步方法)
  5. 懒汉式(线程安全，同步代码块)
  6. 双重检查
  7. 静态内部类
  8. 枚举

饿汉式（静态常量）

  1. 构造器私有化 (防止 new )
  2. 类的内部创建对象
  3. 向外暴露一个静态的公共方法。getInstance
  4. 代码实现
package com.jinxu.singleton.type1;

public class SingletonTest01 {

	public static void main(String[] args) {
		//测试
		Singleton instance = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance == instance2); // true
		System.out.println("instance.hashCode=" + instance.hashCode());
		System.out.println("instance2.hashCode=" + instance2.hashCode());
	}

}

//饿汉式(静态变量)

class Singleton {
	
	//1. 构造器私有化, 外部能new
	private Singleton() {
		
	}
	
	//2.本类内部创建对象实例
	private final static Singleton instance = new Singleton();
	
	//3. 提供一个公有的静态方法，返回实例对象
	public static Singleton getInstance() {
		return instance;
	}
	
}

优缺点说明：

  1. 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
  2. 缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则 会造成内存的浪费。
  3. 这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大 多数都是调用 getInstance 方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静 态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果 。
  4. 结论：这种单例模式可用，可能造成内存浪费。

饿汉式（静态代码块）

package com.jinxu.singleton.type2;

public class SingletonTest02 {

	public static void main(String[] args) {
		//测试
		Singleton instance = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance == instance2); // true
		System.out.println("instance.hashCode=" + instance.hashCode());
		System.out.println("instance2.hashCode=" + instance2.hashCode());
	}

}

//饿汉式(静态变量)

class Singleton {
	
	//1. 构造器私有化, 外部能new
	private Singleton() {
		
	}
	

	//2.本类内部创建对象实例
	private  static Singleton instance;
	
	static { // 在静态代码块中，创建单例对象
		instance = new Singleton();
	}
	
	//3. 提供一个公有的静态方法，返回实例对象
	public static Singleton getInstance() {
		return instance;
	}
	
}

优缺点说明：

  1. 这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执 行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
  2. 结论：这种单例模式可用，但是可能造成内存浪费。

懒汉式(线程不安全)

package com.jinxu.singleton.type3;


public class SingletonTest03 {

	public static void main(String[] args) {
		System.out.println("懒汉式1 ， 线程不安全~");
		Singleton instance = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance == instance2); // true
		System.out.println("instance.hashCode=" + instance.hashCode());
		System.out.println("instance2.hashCode=" + instance2.hashCode());
	}

}

class Singleton {
	private static Singleton instance;
	
	private Singleton() {}
	
	//提供一个静态的公有方法，当使用到该方法时，才去创建 instance
	//即懒汉式
	public static Singleton getInstance() {
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

优缺点说明：

  1. 起到了 Lazy Loading 的效果，但是只能在单线程下使用。
  2. 如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过 了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式 。
  3. 结论：在实际开发中，不要使用这种方式.

懒汉式(线程安全，同步方法)

package com.jinxu.singleton.type4;


public class SingletonTest04 {

	public static void main(String[] args) {
		System.out.println("懒汉式2 ， 线程安全~");
		Singleton instance = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance == instance2); // true
		System.out.println("instance.hashCode=" + instance.hashCode());
		System.out.println("instance2.hashCode=" + instance2.hashCode());
	}

}

// 懒汉式(线程安全，同步方法)
class Singleton {
	private static Singleton instance;
	
	private Singleton() {}
	
	//提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
	//即懒汉式
	public static synchronized Singleton getInstance() {
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

优缺点说明：

  1. 解决了线程安全问题。
  2. 效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。而其实这个方法只执行 一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低。
  3. 结论：在实际开发中，不推荐使用这种方式。

懒汉式(线程安全，同步代码块)

不推荐

双重检查

package com.jinxu.singleton.type6;


public class SingletonTest06 {

	public static void main(String[] args) {
		System.out.println("双重检查");
		Singleton instance = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance == instance2); // true
		System.out.println("instance.hashCode=" + instance.hashCode());
		System.out.println("instance2.hashCode=" + instance2.hashCode());
		
	}

}

// 懒汉式(线程安全，同步方法)
class Singleton {
	private static volatile Singleton instance;
	
	private Singleton() {}
	
	//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
	//同时保证了效率, 推荐使用
	
	public static Singleton getInstance() {
		if(instance == null) {
			synchronized (Singleton.class) {
				if(instance == null) {
					instance = new Singleton();
				}
			}
			
		}
		return instance;
	}
}

优缺点说明：

  1. Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这 样就可以保证线程安全了。
  2. 这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避 免的反复进行方法同步.。
  3. 线程安全；延迟加载；效率较高 。
  4. 结论：在实际开发中，推荐使用这种单例设计模式。

静态内部类

package com.jinxu.singleton.type7;


public class SingletonTest07 {

	public static void main(String[] args) {
		System.out.println("使用静态内部类完成单例模式");
		Singleton instance = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance == instance2); // true
		System.out.println("instance.hashCode=" + instance.hashCode());
		System.out.println("instance2.hashCode=" + instance2.hashCode());
		
	}

}

// 静态内部类完成， 推荐使用
class Singleton {
	private static volatile Singleton instance;
	
	//构造器私有化
	private Singleton() {}
	
	//写一个静态内部类,该类中有一个静态属性 Singleton
	private static class SingletonInstance {
		private static final Singleton INSTANCE = new Singleton(); 
	}
	
	//提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
	
	public static Singleton getInstance() {
		
		return SingletonInstance.INSTANCE;
	}
}

优缺点说明

  1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
  2. 静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才 会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
  3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行 初始化时，别的线程是无法进入的。 4) 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
  4. 结论：推荐使用.

枚举

package com.jinxu.singleton.type8;

public class SingletonTest08 {
	public static void main(String[] args) {
		Singleton instance = Singleton.INSTANCE;
		Singleton instance2 = Singleton.INSTANCE;
		System.out.println(instance == instance2);
		
		System.out.println(instance.hashCode());
		System.out.println(instance2.hashCode());
		
		instance.sayOK();
	}
}

//使用枚举，可以实现单例, 推荐
enum Singleton {
	INSTANCE; //属性
	public void sayOK() {
		System.out.println("ok~");
	}
}

优缺点说明

  1. 这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建 新的对象。
  2. 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式 。
  3. 结论：推荐使用

单例模式注意事项和细节说明

  1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使 用单例模式可以提高系统性能。
  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new。
  3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级 对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)。

java设计模式往期回顾：
设计模式原则demo示例下载

1.java设计模式
2.java设计模式原则——单一职责原则
3.java设计模式原则——接口隔离原则
4.java设计模式原则——依赖倒置原则
5.java设计模式原则——里氏替换原则
6.java设计模式原则——开闭原则
7.java设计模式原则——迪米特法则
8.java设计模式原则——合成复用原则
9.java设计模式概述和分类

呆萌坦然
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式——单例模式
08-11
**设计模式——单例模式** 在软件工程中，设计模式是一种在特定场景下解决常见问题的标准方案，可以被复用并提升代码质量。单例模式是设计模式中的一种，它保证一个类只有一个实例，并提供一个全局访问点。这种模式...
Java设计模式——单例模式
m0_60500421的博客
08-16 1739
Java设计模式——单例模式
Java 设计模式——单例模式
代码星辰的博客
07-08 4191
本文介绍了单例模式的相关知识。
JAVA设计模式——单例模式
最新发布
2301_77760093的博客
03-04 890
单例模式是一种创建型设计模式，其主要目的是确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。单例模式通常用于需要在整个应用程序中共享某个资源或控制某个独占性资源的情况。在单例模式中，通常会将类的构造函数设为私有（private），以防止外部直接实例化该类。同时，类内部会维护一个静态成员变量来保存唯一的实例，并提供一个静态方法来获取或创建这个实例。单例模式有多种实现方式，包括懒汉式、饿汉式、双重检查锁等，需要注意的是，在多线程环境下，需要考虑线程安全性，确保单例模式能够正确地工作。
java设计模式之——单例模式
03-20
单例模式是软件设计模式中的一种经典模式，其主要目的是控制类的实例化过程，确保在任何情况下，一个类只有一个实例存在。这种模式通常用于管理共享资源或者全局配置，例如数据库连接池、线程池、日志服务等。在Java...
设计模式——单例模式（懒汉模式）
08-10
单例模式是软件设计模式中的一种经典模式，它保证了类在任何情况下都只有一个实例存在。这个模式在很多场景下非常有用，例如控制全局资源、管理配置信息等。本文将详细探讨单例模式的懒汉式实现，并结合源码进行解析...
设计模式实现——单例模式
09-03
单例模式是软件设计模式中的一种，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式在很多场景下都非常有用，比如控制共享资源、管理系统级别的服务或者简化对象间的交互。单例模式的核心在于...
java设计模式——迭代器模式
u014627852的博客
07-01 1300
看一个具体的需求 编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。如图： 传统的设计方案(类图) 传统的方式的问题分析 将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。 实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好实现的遍历的操作。 3)解决方案：=>迭代器模式。 迭代器模式基本介绍 迭代器模式（Iterator Pa
java设计模式原则——里氏替换原则
u014627852的博客
06-13 924
设计模式回顾： 1.java设计模式 2.java设计模式原则——单一职责原则 3.java设计模式原则——接口隔离原则 4.java设计模式原则——依赖倒置原则 设计模式demo示例下载 OO 中的继承性的思考和说明 继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有 的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。 继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低
java设计模式——模板方法模式
u014627852的博客
06-28 713
豆浆制作问题 编写制作豆浆的程序，说明如下: 制作豆浆的流程选材—>添加配料—>浸泡—>放到豆浆机打碎。 通过添加不同的配料，可以制作出不同口味的豆浆。 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的。 请使用模板方法模式完成 。 模板方法模式基本介绍 模板方法模式（Template Method Pattern），又叫模板模式(Template Pattern)，在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象
java设计模式——代理模式
u014627852的博客
06-27 622
代理模式(Proxy)基本介绍 代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象 代理模式有不同的形式,主要有三种静态代理、动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴)。 代理模式示意图 静态代理 静态代理在使用时,需要定义接口
java设计模式——适配器模式
u014627852的博客
06-18 539
基本介绍 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本 因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapper)。 适配器模式属于结构型模式。 主要分为三类：类适配器模式、对象适配器模式、接口适配器模式。 工作原理 适配器模式：将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容。 从用户的角度看不到被适配者，是解耦的。 用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法。 用户
java设计模式——命令模式
u014627852的博客
06-29 482
智能生活项目需求 我们买了一套智能家电，有照明灯、风扇、冰箱、洗衣机，我们只要在手机上安装app就可以控制对这些家电工作。 这些智能家电来自不同的厂家，我们不想针对每一种家电都安装一个App，分别控制，我们希望只要一个 app就可以控制全部智能家电。 要实现一个 app控制所有智能家电的需要，则每个智能家电厂家都要提供一个统一的接口给 app调用，这时就可以考虑使用命令模式。 命令模式可将“动作的请求者”从“动作的执行者”对象中解耦出来。 在我们的例子中，动作的请求者是手机app，动作的执行者是
java设计模式——策略模式
u014627852的博客
07-06 472
编写鸭子项目，具体要求如下: 有各种鸭子(比如野鸭、北京鸭、水鸭等，鸭子有各种行为，比如叫、飞行等)。 显示鸭子的信息。 传统方案解决鸭子问题的分析和代码实现 传统的设计方案(类图) 代码演示 package com.jinxu.strategy; public abstract class Duck { public Duck() { } public abstract void display();//显示鸭子信息 public void quack() { Syst
java设计模式——外观模式
u014627852的博客
06-26 472
影院管理项目 组建一个家庭影院： DVD播放器、投影仪、自动屏幕、环绕立体声、爆米花机,要求完成使用家庭影院的功能，其过程为： 直接用遥控器：统筹各设备开关 开爆米花机 放下屏幕 开投影仪 开音响 开 DVD，选 dvd 去拿爆米花 调暗灯光 播放 观影结束后，关闭各种设备 传统方式解决影院管理 在 ClientTest的 main方法中，创建各个子系统的对象，并直接去调用子系统(对象)相关方法，会造成调用过程混乱，没有清晰的过程。 不利于在 ClientTest中，去维护对子系统的操作。 解决思路
java设计模式——备忘录模式
u014627852的博客
07-04 448
游戏角色状态恢复问题 游戏角色有攻击力和防御力，在大战 Boss前保存自身的状态(攻击力和防御)，当大战 Boss后攻击力和防御力下降，从备忘录对象恢复到大战前的状态。 传统方案解决游戏角色恢复 传统的方式的问题分析 一个对象，就对应一个保存对象状态的对象，这样当我们游戏的对象很多时，不利于管理，开销也很大。 传统的方式是简单地做备份，new出另外一个对象出来，再把需要备份的数据放到这个新对象，但这就暴露了对象内部的细节。 解决方案： =>备忘录模式 备忘录模式基本介绍 备忘录模式（
java设计模式——职责链模式
u014627852的博客
07-06 401
学校 OA系统的采购审批项目 需求是采购一批教材 如果金额小于等于 5000,由教学主任审批（0<=x<=5000)。 如果金额小于等于 10000,由院长审批 (5000<x<=10000)。 如果金额小于等于 30000,由副校长审批 (10000<x<=30000)。 如果金额超过 30000以上，有校长审批 ( 30000<x)。 传统方案解决 OA系统审批，传统的设计方案(类图) 问题分析 传统方式
Java面向对象（高级）- 单例(Singleton)设计模式
11-19
"Java面向对象的高级主题——单例设计模式" 单例设计模式是一种在软件工程中广泛使用的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式在很多场景下非常有用，例如管理共享资源、控制...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值