设计模式学习（一）单例设计模式

程序胖
214 阅读7分钟

这是我参与11月更文挑战的第11天，活动详情查看：2021最后一次更文挑战

单例模式介绍

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

单例模式的实现方式

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

饿汉式-静态常量

  1. 步骤：
    • 构造器私有化 ，防止 new
    • 类的内部创建对象
    • 向外暴露一个静态的公共方法，getInstance方法
  2. 代码实现：
public class SingleTon1 {
	public static void main(String[] args) {
		SingleTon singleTon1 = SingleTon.getInstance();
		SingleTon singleTon2 = SingleTon.getInstance();
		System.out.println(singleTon1.equals(singleTon2));
		
	}

}
class SingleTon{
	
	//1. 私有构造方法，防止外部类访问
	private SingleTon() {
		
	}
	
	//2. 创建一个静态属性的对象
	private final static SingleTon singleTon = new SingleTon();
	
	//3. 提供一个public的静态方法，返回对象
	public static SingleTon getInstance() {
		return singleTon;
	}
	
}
  1. 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题 。
  2. 缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

饿汉式-静态代码块

  1. 步骤：
    • 构造器私有化 ，防止 new
    • 定义本类
    • 静态代码块创建对象
    • 向外暴露一个静态的公共方法，getInstance方法
  2. 代码：
public class SingleTon2 {

	public static void main(String[] args) {
		SingleTon02 singleTon1 = SingleTon02.getInstance();
		SingleTon02 singleTon2 = SingleTon02.getInstance();
		System.out.println(singleTon1.equals(singleTon2));
		
	}

}
class SingleTon02{
	
	//1. 私有构造方法，防止外部类访问
	private SingleTon02() {
		
	}
	
	//2. 定义本类
	private final static SingleTon02 singleTon;
	
	//3. 静态代码块创建对象
	static {
		singleTon = new SingleTon02();
	}
	
	//4. 提供一个public的静态方法，返回对象
	public static SingleTon02 getInstance() {
		return singleTon;
	}
	
}
  1. 结论：这个方法跟上面的方法大致相似，所以优缺点也类似，都是可能造成内存浪费。

懒汉式-线程不安全

  1. 步骤：
    1. 定义对象
    2. 私有构造方法
    3. 当调用方法时，才创建实例
  2. 代码：
public class SingleTon3 {

	public static void main(String[] args) {
		SingleTon03 singleTon1 = SingleTon03.getInstance();
		SingleTon03 singleTon2 = SingleTon03.getInstance();
		System.out.println(singleTon1.equals(singleTon2));
	}

}
class SingleTon03{
	
	//1. 定义对象
	private static SingleTon03 singleTon;
	//2. 私有构造方法
	private SingleTon03(){
		
	}
	//3. 当调用方法时，才创建实例
	public static SingleTon03 getInstance() {
		if(singleTon==null)
			singleTon = new SingleTon03();
		return singleTon;
	}
	
}
  1. 结论：
    • 起到了懒加载（你要使用的时候才创建，减少内存浪费）的效果，但是只能在单线程下使用 。
    • 如果在多线程下，一个线程进入了 if (singleton == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
    • 在实际开发中，不要使用这种方式

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

  1. 步骤：
    1. 定义对象
    2. 私有构造方法
    3. 当调用方法时，才创建实例（给方法加了一把锁）
  2. 代码：
public class SingleTon4 {

	public static void main(String[] args) {
		SingleTon04 singleTon1 = SingleTon04.getInstance();
		SingleTon04 singleTon2 = SingleTon04.getInstance();
		System.out.println(singleTon1.equals(singleTon2));
	}

}
class SingleTon04{
	
	//1. 定义对象
	private static SingleTon04 singleTon;
	//2. 私有构造方法
	private SingleTon04(){
		
	}
	//3. 当调用方法时，才创建实例,加入同步代码
	public static synchronized SingleTon04 getInstance() {
		if(singleTon==null)
			singleTon = new SingleTon04();
		return singleTon;
	}
	
}
  1. 结论：
    • 解决了线程不安全问题
    • 效率太低了，每个线程在想获得类的实例时候，执行 getInstance() 方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太 低
    • 在实际开发中， 不推荐使用这种方式

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

  1. 步骤：
    1. 定义对象
    2. 私有构造方法
    3. 当调用方法时，才创建实例（同步代码块）
  2. 代码：
public class SingleTon5 {

	public static void main(String[] args) {
		SingleTon05 singleTon1 = SingleTon05.getInstance();
		SingleTon05 singleTon2 = SingleTon05.getInstance();
		System.out.println(singleTon1.equals(singleTon2));
	}

}
class SingleTon05{
	
	//1. 定义对象
	private static SingleTon05 singleTon;
	//2. 私有构造方法
	private SingleTon05(){
		
	}
	//3. 当调用方法时，才创建实例,加入同步代码块
	public static SingleTon05 getInstance() {
		if(singleTon==null) {
			synchronized(SingleTon05.class) {
				singleTon = new SingleTon05();
			}
		}
		return singleTon;
	}
	
}
  1. 结论：
    • 相比于前面一个方法，效率确实高了
    • 但是线程不安全了，是这种同步并不能起到线程同步的作用 。跟第 3 种实现方式遇到的情形一致，假如一个线程进入了 if (singleton == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例

双重检查

  1. 代码：
public class SingleTon6 {

	public static void main(String[] args) {
		SingleTon06 singleTon1 = SingleTon06.getInstance();
		SingleTon06 singleTon2 = SingleTon06.getInstance();
		System.out.println(singleTon1.equals(singleTon2));
	}

}
class SingleTon06{
	
	//1. 定义对象
	private static volatile SingleTon06 singleTon;
	//2. 私有构造方法
	private SingleTon06(){
		
	}
	//3. 当调用方法时，才创建实例
	public static SingleTon06 getInstance() {
		if(singleTon==null) {
			//当多线程进入if语句的时候，有锁限制一个线程进去
			synchronized(SingleTon05.class) {
				//当一个线程进去之后发现没有创建就会创建，有了就不会创建了。
				if (singleTon==null) {
					singleTon = new SingleTon06();
				}
			}
		}
		return singleTon;
	}
	
}
  1. 结论：
    • Double Check 概 念 是 多 线程开 发中常使用到的， 如代码中所示，我们进行了两次 if (singleton == null) 检查，这样就可以保证线程安全了 。
    • 这 样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)直接 return 实例化对 象，也避免的反复进行方法同步
    • 线程安全；延迟加载；效率较高
    • 在实际开发中，推荐使用这种单例设计模式

静态内部类

  1. 代码：
public class SingleTon7 {

	public static void main(String[] args) {
		SingleTon07 singleTon1 = SingleTon07.getInstance();
		SingleTon07 singleTon2 = SingleTon07.getInstance();
		System.out.println(singleTon1.equals(singleTon2));
	}

}
class SingleTon07{
	
	//1. 私有构造方法
	private SingleTon07(){
		
	}
	//2. 静态内部类
	private static class SingleTonInstance{
		private static final SingleTon07 singleTon = new SingleTon07();
	}
	//3. 创建对外接口
	public static SingleTon07 getInstance() {
		return SingleTonInstance.singleTon;
	}
	
}
  1. 结论：
    • 这种方式采用了类装载的机制来保证初始化实例时只有一个线程 。
    • 静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化 。
    • 类的静态属性只会在第一次加载类的时候初始化，所以在这里， JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的 。
    • 优点：避免了 线程不安全 ，利用静态内部类特点实现延 迟加载，效率高

枚举

  1. 代码：

enum Singleton{
	INSTANCE;
	public void method(){
		//写方法;
	}
}
  1. 结论：这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

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

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