设计模式（二）--- 单例模式

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

单例模式

所谓类的单例设计模式，就是采取一一定的方法保证在整个的软件系统中，对某个类
只能存在-一个对象实例，并且该类只提供-一个取得其对象实例的方法(静态方法)。

例子：比如Hibernate的SessionFactory,它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的， 一般情况下，一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式。

单例模式有八种方式:

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

public class singletonTest01 {
	
	public static void main(String[] args) {
		
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println(instance1 == instance2);
		System.out.println(instance1.hashCode());
		System.out.println(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. 结论:这种单例模式可用，可能造成内存浪费
2、 饿汉式(静态代码块)
package 单例模式;

public class singletonTest01 {
	
	public static void main(String[] args) {
		
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance1 == instance2);
		System.out.println(instance1.hashCode());
		System.out.println(instance2.hashCode());
	}

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

优缺点：

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

public class singletonTest01 {
	
	public static void main(String[] args) {
		
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance1 == instance2);
		System.out.println(instance1.hashCode());
		System.out.println(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 == nul)判断语句块，还未来得及
    往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以
    在多线程环境下不可使用这种方式
  3. 结论:在实际开发中，不要使用这种方式.
4、 懒汉式(线程安全，同步方法)
package 单例模式;

public class singletonTest01 {
	
	public static void main(String[] args) {
		
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance1 == instance2);
		System.out.println(instance1.hashCode());
		System.out.println(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. 结论:在实际开发中，不推荐使用这种方式
5、 懒汉式(线程安全，同步代码块)
package 单例模式;

public class singletonTest01 {
	
	public static void main(String[] args) {
		
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance1 == instance2);
		System.out.println(instance1.hashCode());
		System.out.println(instance2.hashCode());
	}

}
//懒汉式(线程安全，同步方法)
class Singleton{
	
	private static Singleton instance;
	
	private Singleton() {
		
	}
	
	//提供一个静态公有方法，
	public static Singleton getInstance() {
		
		if(instance == null) {
			synchronized (Singleton.class) {
				instance = new Singleton();
			}
			
		}
		return instance;
	}
}

优缺点说明:

  1. 这种方式，本意是想对第四种实现方式的改进，因为前面同步方法效率太低，
    改为同步产生实例化的的代码块
  2. 但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一
    致，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，
    另一个线程也通过了这个判断语句，这时便会产生多个实例
  3. 结论:在实际开发中，不能使用这种方式
6、双重检查
package 单例模式;

public class singletonTest01 {
	
	public static void main(String[] args) {
		
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance1 == instance2);
		System.out.println(instance1.hashCode());
		System.out.println(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 == nul)检查，这样就可以保证线程安全了。
  2. 这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton - null),
    直接return实例化对象，也避免的反复进行方法同步.
  3. 线程安全:延迟加载;效率较高
  4. 结论:在实际开发中，推荐使用这种单例设计模式
7、 静态内部类
package 单例模式;

public class singletonTest01 {
	
	public static void main(String[] args) {
		
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance1 == instance2);
		System.out.println(instance1.hashCode());
		System.out.println(instance2.hashCode());
	}

}
//静态内部类,推荐使用
class Singleton{
	
	private static volatile Singleton instance;
	
	//构造器私有化
	private Singleton() {
		
	}
	
	//写一个静态内部类，该类中有一个静态属性Singleton
	private static class SingletonInstance{
		private static final Singleton INSTANCE = new Singleton();
	}

	//提供一个静态公有方法，直接返回SingletonInstance
	public static Singleton getInstance() {
		
		return SingletonInstance.INSTANCE;
	}
}

优缺点:

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

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

}
//枚举
enum Singleton {
	INSTANCE;
}

优缺点:

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

注意事项和细节

  1. 单例模式保证了系统内存中该类只存在-一个对象，节省了系统资源，对于一-些需
    要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2. 当想实例化-一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使
    用new
  3. 单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或
    耗费资源过多(即:重量级对象)，但又经常用到的对象、工具类对象、频繁访问数
    据库或文件的对象(比如数据源、session工厂 等)
小苗要努力变强
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式（一）- 单例模式
u010775636的博客
05-31 113
1.简述单例模式是应用最广泛的模式之一，定义就是单例对象的类必须保证只有一个实例存在。单例模式适用于创建一个对象需要消耗过多资源的情况，例如访问数据库等资源是需要考虑使用。实现单例模式的关键点如下:构造函数私有化（才不会让你有机会再创建一个对象）通过一个静态方法或枚举（后面会有举例）返回单例类对象确保单例类的对象有且只有一个，尤其是多线程环境下（同时是难点）确保单例类的对象在反序列化是不会重新构建...
设计模式篇二（单例模式）
Jeeper_的专栏
12-30 561
1、什么是单例模式：确保一个类仅有一个唯一的实例，并且提供一个全局的访问点。2、环境及问题： 如上图所示，每次使用一个类的时候，首先都需要实例化一个对象。不管是new还是定义局部变量。但多次调用new，就会拿到多次该对象的实例。那有没有这样一种情况：多次调用new时都拿到同一个实例化对象？比如数据库连接，大家都知道建立一个数据库连接消耗的资源是巨大的，那是不是每次需要操作数据库的时候都要先建立一个
单例模式的使用：唯一的月亮
汪程序员
04-10 579
描述 编写一个窗口图形应用程序，使用单例模式类中 的类方法得到单例类的唯一实例（月亮的信息）， 运行效果如下图所示。 解决 单例模式的使用：唯一的月亮 运行截图： 代码 package Simple; import java.awt.*; import javax.swing.*; public class homework extends JFrame{ public homework(String name) { } public static void main(
单例模式
u011569827的博客
09-09 174
介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。 比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就足够了，这就是使用到了单例模式。 单例模式的实现有八种方式： 饿汉式（静态常量） 饿汉式（静态代码块） 懒汉式（线程不安全） 懒汉式（线程安
Java单例模式
VickyMWW的博客
07-29 132
某公司研发星球维护系统，请使用饿汉式单例模式的实现思想，设计编写地球类。 程序运行参考效果图如下： package com.dodoke.third; public class Earth { private Earth(){ System.out.println("地球诞生"); } private static Earth instance = new Earth(); public static Earth getInstance(){ return instance; }
设计模式-单例模式
yuxiangzju的博客
07-30 313
单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例类必须自己创建
设计模式——单例模式
柚咖小窝
01-09 123
单例模式：保证类在内存中只有同一个对象
ava常用设计模式-单例模式
08-26
ava常用设计模式-单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一...
Java设计模式-单例模式详解
11-24
Java设计模式-单例模式详解 单例模式是 Java 设计模式中的一种常用的设计模式，旨在保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式的目的是为了保证在一个进程中，某个类有且仅有一个实例。 ...
常见设计模式-单例模式
07-06
单例模式是设计模式中的一种，其主要目的是确保一个类只有一个实例，并且提供一个全局访问点来获取这个实例。在Java编程中，实现单例模式有多种方式，每种方式都有其优缺点。 1. **饿汉式**： 饿汉式在类加载时即...
c++设计模式-单例模式
06-03
**单例模式**是软件设计模式中的一种，属于创建型模式。在C++中，单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于管理共享资源，如数据库连接、日志系统或者配置文件等。单例模式的主要...
java设计模式-单例.pdf
05-16
设计模式 java设计模式-单例.pdf
（java基础学习）单例设计模式
xwhokay的博客
08-22 145
单例模式 （1）所谓单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 （2）单例模式两种方式：饿汉式和懒汉式 1.饿汉式和懒汉式单例模式实现 步骤如下 （1）先私有化构造器，防止直接new、 （2）类内部创建对象 （3）向外暴露一个静态的公共方法 （4）代码实现 例1： 饿汉式 package com.hspedu.single_; public class StringTon01 { public
Kotlin与Java的混合开发
手写我对你的温柔
05-05 9216
包括基本的互操作行为、SAM转换、正则表达式、集合框架、IO操作：[实际上用到i的还是 java的api，只不过要注意kotlin为我们提供了很多扩展方法]、装箱和拆箱、注解处理器。 下面一一介绍: 1.基本的互操作行为: 1.属性读写： Kotlin自动识别 Java Getter/Setter Java操作Kotlin属性通过Getter/Setter 2.空安全类型： Ko...
kotlin和java混合开发总结
feelinghappy的专栏
09-15 1393
声明：本文是作者AWeiLoveAndroid原创，版权归作者AWeiLoveAndroid所有，侵权必究。如若转发，请注明作者和来源地址！未经授权，严禁私自转载！ 我本来是不想学习kotlin的，但是现在的形势，很多公司都在使用kotlin开发，可以说学会kotlin也是无奈之举，既然是潮流，谷歌也在大力推广，所以还是只能硬着头皮逼迫自己学一下，也能更快适应公司的需要。正所谓：“识时务者为俊杰”，改变不了公司的发展，那就改变自己。本文首发在 慕课网，转载请注明原文链接和作者信息。 废话少说，直接上正题
设计模式之——单例模式
很高兴你能看到这里
06-19 2592
更酷的是，创建对象的职责和管理单例的职责被拆分在两个不同的方法中，这两个方法组合起来才具有单例模式的威力。你学到了吗，少年？
单例设计模式(8种)
weixin_49329785的博客
08-04 1299
/* * 单例设计模式： * 1.所谓的单例设计模式，就是采用一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。 * * 2.如何实现？ * 饿汉式 vs 懒汉式 * 3.区分饿汉式和懒汉式 * 饿汉式：（创建时就已经存在对象） * 坏处：对象加载时间过长。 * 好处：饿汉式是线程安全的。 * 懒汉式： * 好处：延迟对象的创建 * 目前写法的坏处：线程不安全。---->到多线程内容时，在修改 * */ public class Si.
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1084
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
聊聊设计模式-单例模式
09-29
单例模式是一种创建型设计模式，它保证类仅有一个实例，并提供一个全局访问点。在单例模式中，类会自行创建一个实例，并对外提供一个访问该实例的方法。 单例模式有多种实现方式，其中常见的有懒汉式和饿汉式。懒汉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值