二十三种设计模式之单例模式（八种写法）

最新推荐文章于 2024-09-17 20:50:35 发布
最新推荐文章于 2024-09-17 20:50:35 发布
阅读量171 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39474136/article/details/102491299
版权

在讲单例模式之前。先简单介绍一下二十三种设计模式的类型
本人的设计模式的课程学习地址这里，代码笔记都提供的。

设计模式类型

设计模式分为三种类型，共23种：

  1. 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
  2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
  3. 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)。

单例设计模式介绍

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

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

单例设计模式八种方式

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

（一）饿汉式（静态常量）代码如下：

package com.atguigu.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;
	}
	
}

首先，先将Singleton 类的构造器私有化，防止外部new创建对象，然后直接在代码里面声明一个final（不可变的），的静态变量。然后创建Singleton 的对象实例。提供一个公有的静态方法，返回实例对象。
优缺点说明：

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

（二）饿汉式（静态代码块）代码如下：

package com.atguigu.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 final static Singleton instance;
	
	static { // 在静态代码块中，创建单例对象
		instance = new Singleton();
	}
	
	//3. 提供一个公有的静态方法，返回实例对象
	public static Singleton getInstance() {
		return instance;
	}
	
}

这种写法的优缺点，跟第一种是一样的，只不过，把类的实例化，放到了静态代码块当中而已。

（三）懒汉式(线程不安全) 代码如下：

package com.atguigu.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. 起到了LazyLoading的效果，但是只能在单线程下使用。
  2. 如果在多线程下，一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。是线程不安全的。
  3. 其实不管是不是单线程还是多线程，个人觉得这种方法不推荐使用。

（四）懒汉式(线程安全，同步方法) 代码如下：

package com.atguigu.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. 优点：因为这里加了synchronized ，对getInstance加锁了。所以解决了线程不安全问题 。
  2. 缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低。
  3. 个人不推荐使用。

（五）懒汉式(线程不安全，同步代码块)，对整个类对象加锁：

package com.atguigu.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  Singleton getInstance() {
		if(instance == null) {
			synchronized(Singleton.class){
				instance = new Singleton();
			}
		}
		return instance;
	}
}

这里虽然这里synchronized是对Singleton类加锁，但是弊端还是一样的。

这种同步并不能起到线程同步的作用。这种实现方法，跟第三种遇到的情形一致，假如一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。个人不推荐使用。

（六）双重检查检查写法，代码如下：

package com.atguigu.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;
	}
}

如代码中所示，我们进行了两次if(singleton==null)检查，然后给类对象加锁。当执行了synchronized 里面代码块的代码的时候，再进行一次null的判断，这样就可以避免多个线程的情况下，出现创建多个实例的问题。后面再次访问时，再进行判断。如果不为null，直接return实例化对象，也避免的反复进行方法同步。
这种方式是比较好的一种方式。实现了懒加载，也避免了反复进行方法同步。也解决了线程不安全的问题。效率其实还是可以的。

（七）静态内部类写法，代码如下：

package com.atguigu.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 synchronized Singleton getInstance() {
		
		return SingletonInstance.INSTANCE;
	}
}

优缺点说明：

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

（八）枚举类写法，代码如下：

package com.atguigu.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~");
	}
}

这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

虽然写了八种写法，但是推荐使用的只有五种，饿汉模式两种，双重检查一种，内部类一种，枚举类一种。

坠机的舒克
关注
专栏目录
粗讲二十三种之单例模式！！
qq_40676088的博客
06-01 159
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 二、...
二十三种设计模式之单例模式
weixin_43416686的博客
06-22 126
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 单例模式常见的写法有两种一种是懒汉式，一种是饿汉式。先介绍一下饿汉式。 public class Mge01 { /** * 实例化类的对象 */ priv
博客专栏：二十三种设计模式之单例模式
犁的博客
04-05 475
我将自己学习单例模式的经历表达出来，作为自己学习的一次总结，也希望可以帮到大家。 我觉得这样子的一个学习过程比较合适，我会先将单例模式的五种形式给出来，然后再进行剖析。 学习的过程借鉴了以下博文：http://tedyin.me/2016/03/13/singlton-pattern/ 在看到这篇文章之前，我只了解到前面的几种单例模式，后面的枚举是看了文章才知道的，这篇文章后
二十三种设计模式——单例模式
wufeifan_learner的博客
04-16 211
前页：设计模式总述 单例模式是java中最简单的一种设计模式。所谓单例模式，就是整个程序只允许有一个类的实例，并且向整个系统中提供此事例。有点像C++中被定义为static的变量。 比如当我们某个程序只有一个关于打印机的端口，那么我们必须将这个端口设计为单例的，因为如果当多台电脑使用这个打印机的时候，只允许第一台电脑对此进行操作，否则打印机将引起混乱， 单例模式特点 单例类只能有一个实例。 ...
23种设计模式全集（学习笔记）
牧码人博客@luckyhe.com
09-16 700
序言 这篇文章是作者看完《大话设计模式》（写的很好对于小白来说也很好理解）一书写的。引用了部分作者书中的内容，并加以自己的了解写的文章。23个设计模式其实就是写代码写得多的套路，我记得作者以前软考时也大致看过。但是那时的感悟并不深。结合了工作的经验后，再来学设计模式。感觉自己也已经初入门道。因此写下了这篇全集，解析错误之处欢迎大家指正。 个人认为学习设计模式的目的只有一个，那就是写出高质量的代码。...
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
设计模式之单例模式（七种方法超详细）
weixin_63834061的博客
04-22 1万+
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，也就是说不能使用new关键字来创建对象。
设计模式：23种设计模式之单例模式
王小二(海阔天空)
09-12 836
还是举ThreadA和ThreadB的例子：当Thread经过第一次检查对象为null时，会接着去加锁，然后去执行new SingletonLazy()，上边已经分析过了，改步骤存在重排现象，如果发生重排，即instance分配了内存地址，但是很没有完成初始化工作，而此时ThreadB,刚好执行第一次检查（没有加锁），instance已经分配了地址空间，不再为null，那么ThreadB会获取到没有完成初始化的instance，这就出现了问题。下述为饿汉式的写法，满足了上边说的第1，2条要求。
设计模式之单例模式的5种写法
花若盛开蝴蝶自来，你若精彩天自安排。
03-21 290
1、饿汉模式-单例 public class Singleton{ //私有化成员，初始化即创建实例，会造成不必要资源浪费 private static final Singleton instance = new Singleton(); //私有化构造方法 private Singleton(){}; //统一实例获取方法 public static getInstance(){ return instance; } } 2、懒
Java设计模式之单例模式的七种写法
07-13
Java设计模式之单例模式的七种写法 单例模式是一种常见的设计模式，它确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机的驱动程序对象常...
JavaScript设计模式之单例模式详解
12-11
* 应用：单例模式是一种常用的模式，有一些对象我们往往只需要一个， * 比如线程池、全局缓存、浏览器中的 window 对象等。 */ //--------------singleton-01------------- /*写法1*/ var Singleton = function...
IOS 中两种单例模式的写法实例详解
08-30
在iOS开发中，单例模式是一种常见的设计模式，它确保一个类只有一个实例，并提供一个全局访问点。在Objective-C中，有两种官方推荐的单例模式实现方式，这两种方法都保证了单例对象的线程安全。以下是这两种写法的...
Tom_20170324_Java设计模式之单例模式的七种写法1
08-08
2、单例类必须自己创建自己的唯一实例 3、单例类必须给所有其他对象提供这一实例 2、资源加载和性能：饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会
23种设计模式之单例模式
qq_43589451的博客
07-05 267
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。单例模式的主要有以下角色：单例设计模式分类两种：饿汉式：类加载就会导致该单实例对象被创建懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建 说明：该方式在成员位置声明Singleton
【设计模式】创建型模式（三）：单例模式
书山有路，学海无涯。记录成长，追逐梦想
09-17 1071
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时 确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
【C++ 设计模式】单例模式的两种懒汉式和饿汉式
Hou_lang_LJ的博客
09-14 613
🐧①单例模式：懒汉式和饿汉式；🖊
【JavaEE初阶】多线程(5 单例模式 \ 阻塞队列)
2301_80898480的博客
09-17 875
如有错误，欢迎指出~
5.C-Demo-排序
最新发布
09-20
5.C-Demo-排序_快速排序
java-ssm942基于ssm的保险公司营销管理系统+jsp程序源码数据库含论文.rar
09-20
本系统基于SSM(Spring+SpringMVC+MyBatis)框架,适用于毕业设计， 基于B/S模式, mysql数据库,感兴趣的朋友们可以下载研究一下。 后端采用java语言，ssm框架，mybatis操作数据源，使用软件：idea,eclipse、MySQL。完成了用户登录管理等模块的设计与实现。完成了系统数据库的设计，并基于MySQL数据库管理系统 jdk版本:jdk1.8+ 前端：jsp 开发工具：IDEA 或者eclipse都支持 编程语言: java 框架支持：ssm 数据库: mysql 版本不限 数据库工具：Navicat/SQLyog都可以 详细技术：java+ssm+jsp+MYSQL+MAVEN
Java单例模式深度解析：七种实现方式与线程安全
"Java设计模式之单例模式的七种写法，Tom老师的公开课文档，深入分析单例模式，适合研究设计模式的学习者。" 在软件开发中，单例模式是一种常用的设计模式，它的核心目标是确保类只有一个实例，并提供一个全局访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值