【设计模式】详谈 Java 中的单例模式

最新推荐文章于 2024-05-06 22:08:40 发布

JJJiker

最新推荐文章于 2024-05-06 22:08:40 发布

阅读量222

点赞数

分类专栏： java 文章标签： java 设计模式

本文链接：https://blog.csdn.net/JJJikerUPUP/article/details/90321947

版权

java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Java单例模式

1. 什么是单例模式

单例：保证一个类仅有一个实例，并提供一个访问它的全局访问点
单例模式是一种常见的软件设计模式之一，其目的是保证整个应用中只存在类的唯一实例
如：我们在系统启动时，需要加载一些公共的配置信息，对整个生命周期中都可见且唯一，这时就需要设计成单例模式。
常见的单例模式：spring容器、session工厂、缓存、数据库连接池等

2. 单例模式的联系

单例设计模式常与另一个名词相联系：安全发布对象
安全发布对象：

在静态初识化函数中初始化一个对象的引用
将对象的引用保存到 volatile 类型域或者 AtomicReference 对象中
将对象的引用保存到某个正确构造对象的 final 类型域中
将对象的引用保存到一个由锁保护的域中

3. 常见的单例模式

3.1 懒汉模式

package singletonTest;

/**
 * 懒汉模式
 * 单例实例在第一次使用时创建
 * @author JJJiker
 *
 */
public class SingletonExample1 {
	
	//私有构造函数
	private SingletonExample1() {
		
	}
	
	//单例对象
	private static SingletonExample1 instance = null;
	
	//静态的工厂方法
	public static SingletonExample1 getInstance() {
		if (instance == null) {
			instance = new SingletonExample1();
		}
		return instance;
	}
}

优点：在获取实例的方法中执行实例的初识化，节省系统资源
缺点：1、若初识化工作较多，加载速度缓慢，影响系统性能
2、是线程不安全的设计模式，当多线程同时访问 getInstance() 方法时，可能会产生多个实例

3.2 饿汉模式

package singletonTest;

/**
 * 饿汉模式
 * 单例实例在类装载时加载
 * @author JJJiker
 *
 */
public class SingletonExample2 {
	
	//私有构造函数
	private SingletonExample2() {
		
	}
	
	//单例对象
	private static SingletonExample2 instance = new SingletonExample2();
	
	//静态的工厂方法
	public static SingletonExample2 getInstance() {
		return instance;
	}
}

优点：线程安全
缺点：在类加载时即创建实例，浪费系统资源

3.3 通过synchronized改写懒汉模式（不推荐）

package singletonTest;

/**
 * 通过 synchronized 改写懒汉模式，保证线程安全
 * 单例实例在类装载时加载
 * @author JJJiker
 *
 */
public class SingletonExample3 {
	
	//私有构造函数
	private SingletonExample3() {
		
	}
	
	//单例对象
	private static SingletonExample3 instance = null;
	
	//静态的工厂方法
	public static synchronized SingletonExample3 getInstance() {
		if (instance == null) {
			instance = new SingletonExample3();
		}
		return instance;
	}
}

优点：通过 synchronized 同步锁改写懒汉模式，保证线程安全
缺点：每次进入 getInstance() 方法都会加锁，耗费资源，故不推荐使用

3.4 通过双重同步锁检测机制改写懒汉模式

package singletonTest;

/**
 1.  通过 双重同步锁检测机制  改写懒汉模式，线程不安全
 2.  单例实例在第一次使用时创建
 3. @author JJJiker
 4.  */
public class SingletonExample4 {
	
	//私有构造函数
	private SingletonExample4() {
		
	}
	
	//单例对象
	private static SingletonExample4 instance = null;
	
	//静态的工厂方法
	public static synchronized SingletonExample4 getInstance() {
		if (instance == null) {
			synchronized (SingletonExample4.class) {
				if (instance == null) {
					instance = new SingletonExample4();
				}
			}
		}
		return instance;
	}
}

注：由于 JVM 和 CPU 的优化，发生了指令重排，故此代码不能保证线程安全

预期的执行顺序：

memory = allocate() 分配对象的内存空间
ctorInstance() 初始化对象
instance = memory 设置nstance指向刚分配的内存

JVM 和 CPU 优化，发生了指令重排：

memory = allocate() 分配对象的内存空间
instance = memory 设置nstance指向刚分配的内存
ctorInstance() 初始化对象

3.5 通过volatile限制JVM的指令重排

package singletonTest;

/**
 *  通过volatile限制JVM的指令重排，达到线程安全
 *  单例实例在第一次使用时创建
 * @author JJJiker
 *
 */
public class SingletonExample5 {
	
	//私有构造函数
	private SingletonExample5() {
		
	}
	
	//单例对象 volatile + 双重检测机制 —> 禁止指令重排 
	private volatile static SingletonExample5 instance = null;
	
	//静态的工厂方法
	public static synchronized SingletonExample5 getInstance() {
		if (instance == null) { //双重检测机制
			synchronized (SingletonExample5.class) {
				if (instance == null) {
					instance = new SingletonExample5();
				}
			}
		}
		return instance;
	}
}

通过 volatile 关键字，加上双重同步锁检测机制禁止了指令重排，保证了线程安全

volatile：是一个类型修饰符（type specifier）.volatile的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值

3.6 饿汉模式改写

package singletonTest;

/**
 *  通过 静态代码块 改写饿汉模式
 * 单例实例在类装载时加载
 * @author JJJiker
 *
 */
public class SingletonExample6 {
	
	//私有构造函数
	private SingletonExample6() {
		
	}
	
	//单例对象
	private static SingletonExample6 instance = null;
	
	static {
		instance = new SingletonExample6();
	}
	
	//静态的工厂方法
	public static SingletonExample6 getInstance() {
		return instance;
	}
	
	//测试
	public static void main(String[] args) {
		System.out.println(getInstance().hashCode());
		System.out.println(getInstance().hashCode());
	}
}

通过静态代码块改写饿汉模式，线程安全

测试结果如下

3.7 枚举模式（推荐使用）

package singletonTest;

/**
  *  枚举模式，推荐使用
 * @author JJJiker
 *
 */
public class SingletonExample7 {
	
	//私有构造函数
	private SingletonExample7() {
		
	}
	
	//静态的工厂方法
	public static SingletonExample7 getInstance() {
		return SingletonExample7.INSTANCE.getInstance;
	}

	private enum Singleton{
		INSTANCE;
		
		private SingletonExample7 singleton;
		
		//JVM 保证这一方法只调用一次
		Singleton() {
			singleton = new SingletonExample7();
		}
		
		public SingletonExample7 getInstance() {
			return singleton;
		}
	}
}

优点：天然线程安全，可防止反射生成实例，推荐使用

时间：2019.5.18 23:05