单例设计模式的八种写法及其优缺点分析（java版）

最新推荐文章于 2022-11-10 12:14:25 发布
最新推荐文章于 2022-11-10 12:14:25 发布
阅读量397 收藏 3
点赞数 4
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/codinglover5/article/details/108398814
版权
本文深入探讨了Java中单例设计模式的八种实现方式，包括饿汉式、懒汉式（线程不安全、线程安全）、静态内部类和枚举方式等，分析了每种方式的优缺点。强调了线程安全、延迟加载和内存效率的重要性，并指出在JDK中Runtime类就是一个单例模式的应用实例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

设计模式

是在大量的实践中总结和理论化之后优选的代码结构、编程风格、
以及解决问题的思考方式。设计模免去我们自己再思考和摸索。就像是经典
的棋谱，不同的棋局，我们用不同的棋谱。”套路”

23种设计模式

创建型模式：共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式；
结构模式：共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式；
行为模式：共11种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

单例模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对
某个类 只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构
造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生
类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无
法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，
静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象
的变量也必须定义成静态的。

单例模式的实现方式

1、单例模式之-饿汉式(静态常量)

饿汉式，从名字上也很好理解，就是“比较勤”，实例在初始化的时候就已经建好了，不管你有没有用到，都先建好了再说。好处是没有线程安全的问题，坏处是浪费内存空间
代码：

public class SingleTonTest1 {
	public static void main(String[] args) {		
		Peaple p1 = Peaple.getPeaple();
		Peaple p2 = Peaple.getPeaple();
		System.out.println(p1 == p2);//true表示两个实例对象是同一个对象
	}
}
class Peaple{
	//第一步创建私有的构造器，避免从类的外部通过new的方式去创建对象
	private Peaple() {	
	}
	//第二步   创建静态的实例对象
	private static Peaple peaple = new Peaple();
	//第三步   创建静态的方法返回类中以及创建好的实例对象
	public static Peaple getPeaple() {
		return peaple;
	}
}

 优缺点说明：

  1. 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

  2. 缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费

  3. 这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法， 但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果

  4. 结论：这种单例模式可用，可能造成内存浪费

2、饿汉式（静态代码块）

public class SingleTonHugry {

	public static void main(String[] args) {
		
		Dog d1 = Dog.getDog();
		Dog d2 = Dog.getDog();
		System.out.println(d1==d2);
		System.out.println(d1.hashCode());//比较两个对象的hashcode值是否相同
		System.out.println(d2.hashCode());

	}
}
class Dog{
	private Dog() {		//私有化构造器避免从类的外部去实例化对象
	}
	
	private static Dog instance =null;//声明类的实例对象为null
	
	static {
		instance = new Dog();//将对象的实例化方法在静态代码块中，类加载的时候就之会执行一次
	}
	public static Dog getDog() {		//创建公共的静态方法可以返回需要的实例对象
		return instance;
	}
}

 优缺点说明：

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

3、单例模式之-懒汉式（线程不安全）

懒汉式，顾名思义就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则返回，没有则新建。有线程安全和线程不安全两种写法，区别就是synchronized关键字。

//懒汉式
class Order{
	//第一步私有化类的构造器	
	private Order() {
		
	}
	//第二步声明类的实例变量，但是先不new，而是声明其为null；
	private static Order inctance  = null;
	
	//第三步  创建静态方法返回实例对象
	public static Order getOrder() {
		if (inctance == null) {
			inctance = new  Order();
		}
		return  inctance;
	}
}

 优缺点说明：

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

4、懒汉式（线程安全、同步方法）

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. 结论：在实际开发中，不推荐使用这种方式

5、懒汉式（线程安全、同步代码块）

在这里插入图片描述懒汉式(线程安全，同步代码块)

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

6、懒汉式（线程安全、双重检查）

public class LazyTest1 {

	public static void main(String[] args) {
		System.out.println("懒加载的双重锁、双重检查、线程安全");
	Singleton s1 =	Singleton.getSingleton();
	Singleton s2 =	Singleton.getSingleton();
	
	System.out.println(s1==s2);
	System.out.println(s1.hashCode());
	System.out.println(s2.hashCode());
	}
}
class Singleton{
	
	private Singleton() {
		
	}
	private static volatile Singleton singleton = null;
	//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用

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

 优缺点说明：

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

7、静态内部类

public class LazyTest1 {

	public static void main(String[] args) {
		System.out.println("静态内部类实现单例模式");
	Singleton s1 =	Singleton.getSingleton();
	Singleton s2 =	Singleton.getSingleton();
	
	System.out.println(s1==s2);
	System.out.println(s1.hashCode());
	System.out.println(s2.hashCode());
	}
}
//静态内部类
class Singleton{
	//构造器私有化
	private Singleton() {
		
	}
	//静态内部类   类中有一个静态属性
	private static class SingleTon{
		private static  Singleton INSTANCE = new Singleton();
	}
		//提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
	public static Singleton getSingleton() {		
		return SingleTon.INSTANCE;
	}
}

 优缺点说明：

  1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。

  2. 静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。

  3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

  4. 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

  5. 结论：推荐使用.

8、通过枚举的方式实现单例模式

public class SingletonEnum {

	public static void main(String[] args) {
		
	Singleton s1 = 	Singleton.INSTANCE;
	Singleton s2 = 	Singleton.INSTANCE;
	System.out.println(s1==s2);
	System.out.println(s1.hashCode());
	System.out.println(s2.hashCode());
	
	}
}
//通过枚举的方式实现单例模式
enum Singleton{
	INSTANCE;	
	public void say() {
		System.out.println("i  am  ok");
	}
}

 优缺点说明：

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

单例模式在JDK中的实例

  1. 我们 JDK 中，java.lang.Runtime 就是经典的单例模式(饿汉式)在这里插入图片描述

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

  1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能

  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new

  3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)

JAVA单例模式分析及其实现：饿汉式、懒汉式、双重检查、静态内部类
wayne_lee_lwc的博客
02-08 471
本文是对站中学院视频单例模式的学习笔记。视频在此 直入正题 单例模式是什么 首先，单例模式是设计模式的一种，是对类的编写的一种模式规范。具体到单例模式， 通俗说，例就是实例，就是对象；单就是一，代表唯一。所以说，单例模式，就是该类仅能有一个实例化对象的设计模式。 较全面的说，单例模式即使保证在整个应用程序的生命周期中的任意时刻，单例模式类的实例都只存在不超过一个（一个或者不存在）。 单例模式实现基...
设计模式学习（五）：单例模式及其优化示例（C语言）
Rain_Mic的博客
02-24 591
一、前言 单例模式（Singleton Pattern）是最简单的设计模式之一，因此并不为其专门开一次研讨会，在闲余时间自行学习，接下来我们来看看该模式的具体内容。、 二、单例模式 单例模式即保证一个类仅有一个实例，并提供一个访问它的全局访问点 单例模式本质上就是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可 以被创建（通过截取创建新对象的请求），并且它可以提供一个访问该实例的方法。 由此可见，单例模式主要是用来避免 一个全局使用的类被频繁地创建与销毁 的情况，当我们想控制实例数目或者节省系统资
单例设计模式的优缺点和设计思想
06-02
单例设计模式的优缺点 设计思想 举例表示
设计模式之单例设计模式
smile radiantly
11-24 177
单例设计模式 1.单例设计模式介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例， 并且该类只提供一个取得其对象实例的方法(静态方法)。 比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 Session...
单例设计模式八种写法
weixin_30276935的博客
09-22 380
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类 只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session 对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory就够，这是就会使用...
单例模式的五种写法
热门推荐
absolute_chen的博客
06-23 24万+
设计模式（Design pattern），提供了在软件开发过程中面临的一些问题的最佳解决方案，是Java开发者必修的一门课程。主要分创建型模式、结构型模式和行为型模式。其中接下来我们要写的是单例模式，属于创建型模式。 单例模式，顾名思义就是只有一个实例，并且她自己负责创建自己的对象，这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。下面我们来看下有哪几种实现方式吧...
单例设计模式的几种简单写法。
weixin_45794957的博客
10-29 136
public class Singleton{ private static Singleton singleton=null; //将自己封装起来 private Singleton(){}; //构造器私有，提供一个可以供外部访问的接口。 public static Singleton forInstance(){ if(singleton==null){ singleto...
详解java中的6种单例写法及优缺点
08-26
下面我们将详解 Java 中的 6 种单例写法及其优缺点。 1. 初级写法 这种写法是最基本的单例写法，它使用一个静态变量来存储单例对象，并提供一个静态方法来获取该对象。但是，这种写法存在一个问题：在并发环境下，...
呕心整理Java中的12种常用设计模式以及应用场景
只为code醉的博客
11-10 1万+
策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。每个if判断都可以理解为就是一个策略，可以使得算法可独立于使用它的用户而变化。使用场景：1. 假设现在某超市有三个等级的会员，普通会员，VIP1，VIP2。2. 在结账的时候，三个登记的会员购买了同一种商品，普通会员不打折，VIP1打9折，VIP2打8折。
单例模式的写法
最新发布
03-25
好的，用户想了解如何用代码实现单例设计模式。我之前学过几种实现方式，但得仔细想想，确保正确性。 首先，单例模式的核心是确保一个类只有一个实例，并提供全局访问点。常见的实现方法有饿汉式、懒汉式、静态内部...
单例设计模式的N种写法
early_or_later的博客
04-20 249
一.单例模式简介 单例模式(Singleton Pattern):是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。 确保单例: 1.私有构造方法 2.提供公有方法获取单例对象 二.单例模式的常见写法 1.饿汉式； 2.懒汉式； 3.注册式； 4.ThreadLocal式； (一).饿汉式单例 饿汉式单例是在类加载的时候就立...
设计模式之单例模式的几种写法
leap的博客
04-13 575
前言经过了前面几次的面试，我发现面试官对设计模式方面的提问频率是非常高的，所以学习设计模式是一件刻不容缓的事情，今天我们就来说一下设计模式中的单例模式吧。什么是设计模式？设计模式并不是什么神技，而是一套代码的设计，是经验的总结，使用设计模式是为了实现代码的复用以及“解耦”，关于编程里面解耦的概念可以参考一下下面这篇知乎。 https://www.zhihu.com/question/20821
设计模式之单例模式的七种写法
xiaobudaics的专栏
06-01 332
设计模式之单例模式的七种写法 简介：单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。 许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管
设计模式之单例模式的八种写法
qq_32029605的博客
06-08 197
方式一 class Singleton { private Singleton() { } private static final Singleton INSTANCE = new Singleton(); public static Singleton getInstance() { return INSTANCE; } } 总结 优点：写法简单，在类装载的时候就完成了实例化，避免了线程同步问题 缺点：在类装载的时候就完成了实例化，没有达
单例设计模式的四种实现和各自的优缺点
weixin_41434306的博客
07-18 486
一: 懒汉式 代码实现: public class LazyManSingleTon{ private LazyManSingleTon(){} private static LazyManSingleTon lmst; public static synchronized LazyManSingleTon getInstance(){ if(lmst == null){ lmst...
详解单例模式六种写法的优缺点
志不强者智不达，言不信者行不果
01-12 6993
前言 单例模式:保证一个类有且仅有一个实例. 通过定义我们可知它是创建型的一种, 也是比较简单的一种 单例模式的使用场景: 频繁的进行创建和销毁的对象、创建对象时消耗过多或者消费资源过多,但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象. 下面主要分析一下单例模式的六种写法, 以及优缺点! 饿汉式(静态常量) 懒汉式(线程不安全) 懒汉式(线程安全) 双重检查 静态内部类 枚举 饿汉...
单例设计模式(四种实现与优缺点)
yahuuqq1314的博客
06-27 358
日常编程中，我们在用到对象的时候经常会new一个对象来使用，但是对于部分常用的对象来说，频繁的创建与销毁会给我们的服务器带来不小的压力，所以很多时候我们需要创建单例对象来避免这种情况发生。 单例的创建大致分为四种: 饿汉式 懒汉式 静态内部类 枚举 饿汉式 代码实现: class Singleton{ //私有化构造器，外部无法new private Singleton(){ } //本类内部创建对象实例 private final static Single
设计模式-----单例模式优缺点及使用场景
任玉
04-25 7451
1、什么是单例模式？        单例模式就是保证系统中一个类只有一个实例。也就是说只能自己new自己并且实例唯一并对外提供。2、模式的作用及应用场景？      作用：解决一个全局使用的类，频繁创建和销毁。拥有对象的唯一性，并保证内存中对象的唯一。可以节省内存，因为单例共用一个实例，有利于Java的垃圾回收机制。                也就是控制资源使用，通过线程同步来控制资源的并发访...
Java中八种单例模式以及各自的优缺点
qq_25017839的博客
04-28 634
1、饿汉式（静态常量）[可用] public class Singleton { private final static Singleton INSTANCE = new Singleton(); private Singleton(){} public static Singleton getInstance(){ return INS...
Java单例模式实现与学习指南
单例模式（Singleton Pattern）是一种常见的设计模式，属于创建型模式。它主要用于确保一个类只有一个实例，并提供一个全局访问点。单例模式适用于那些在整个应用程序中只有一个实例对象的情况，例如配置管理器、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值