1、定义
单例模式(Singleton Pattern)保证某个类在运行期间,只有一个实例对外提供服务,而这个类被称为单例类。
2、结构图
3、单例的实现
3.1、饿汉式
/**
*单例模式-饿汉式
* 在类加载期间初始化私有的静态实例,保证instance实例创建过程是线程安全的.
* 特点: 不支持延时加载,获取实例对象的速度比较快,但是如果对象比较大,而且一直没有使用就会造成内存的浪费.
* @author zhy
*/
public class Singleton_01 {
//1. 私有构造方法
private Singleton_01(){
}
//2. 在本类中创建私有静态的全局对象
private static final Singleton_01 INSTANCE = new Singleton_01();
//3. 提供一个全局访问点,供外部获取单例对象
public static Singleton_01 getInstance(){
return INSTANCE;
}
}
3.2、懒汉式
/**
* 懒加载
* 单例模式-双重校验
* @author zhy
*/
public class Singleton_02 {
//1. 私有构造方法
private Singleton_02(){
}
//2. 在本类中创建私有静态的全局对象
// 使用 volatile保证变量可见性,屏蔽指令重排序
private volatile static Singleton_02 instance;
//3. 获取单例对象的静态方法
public static Singleton_02 getInstance(){
//第一次判断,如果instance不为null,不进入抢锁阶段,直接返回实例
if(instance == null){
synchronized (Singleton_02.class){
//第二次判断,抢到锁之后再次进行判断,判断是否为null
if(instance == null){
instance = new Singleton_02();
/*
上面的创建对象的代码,在JVM中被分为三步:
1.分配内存空间
2.初始化对象
3.将instance指向分配好的内存空间
*/
}
}
}
return instance;
}
3.3、静态内部类
/**
* 单例模式 -静态内部类
* @author zhy
* @date 2022/12/3 14:36
*/
public class Singleton_03 {
private Singleton_03(){
if(SingletonHandler.instance != null){
//throw new RuntimeException("不允许非法访问");
}
}
//创建静态内部类
private static class SingletonHandler{
//在静态内部类中创建单例,在装载内部类的时候,才会创建单例对象
private static Singleton_03 instance = new Singleton_03();
}
public static Singleton_03 getInstance(){
return SingletonHandler.instance;
}
}
3.4、枚举
/**
* 单例模式-枚举
* 阻止反射的破坏: 在反射方法中不允许使用反射创建枚举对象
* 阻止序列化的破坏: 在序列化的时候仅仅是将枚举对象的name属性输出到了结果中,反序列化的时候,就会通过
* Enum的 valueOf方法 来根据名字去查找对应枚举对象.
* @author zhy
*/
public enum Singleton_04 {
INSTANCE;
private Object data;
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public static Singleton_04 getInstance(){
return INSTANCE;
}
}
3.5、测试
//反射对单列的破坏
@Test
void reflect() throws Exception {
Class<Singleton_03> clazz = Singleton_03.class;
Constructor<Singleton_03> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true); //设置为true后,就可以对类中的私有成员进行操作
Singleton_03 instance1 = constructor.newInstance();
Singleton_03 instance = constructor.newInstance();
System.out.println(instance == instance1);
}
//反序列化对单列的破坏
@Test
void test() throws Exception {
//序列化对象输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile.obj"));
oos.writeObject(Singleton_04.getInstance());
//序列化对象输入流
File file = new File("tempFile.obj");
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Singleton_04 singleton03 = (Singleton_04) ois.readObject();
System.out.println(singleton03);
System.out.println(Singleton_04.getInstance());
System.out.println(Singleton_04.getInstance() == singleton03);//false
}
@Test
void ser() throws Exception {
//序列化对象输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile.obj"));
oos.writeObject(Singleton.getInstance());
//序列化对象输入流
File file = new File("tempFile.obj");
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Singleton singleton03 = (Singleton) ois.readObject();
System.out.println(singleton03);
System.out.println(Singleton.getInstance());
System.out.println(Singleton.getInstance() == singleton03);//false
}
}
/**
* 单例类实现序列化接口
*/
class Singleton implements Serializable {
private volatile static Singleton singleton;
private Singleton() {
}
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
/**
* 只需要在单例类中定义readResolve方法,就可以解决序列化对于单例的破坏
* 程序会判断是否有readResolve方法,如果有就执行该方法,如果不存在---就会创建一个新的对象
*/
private Object readResolve(){
return singleton;
}
}
4、总结
饿汉式
- 饿汉式的实现方式,在类加载的期间,就已经将 instance 静态实例初始化好了,所以,instance 实例的创建是线程安全的。不过,这样的实现方式不支持延迟加载实例。
懒汉式-双重检测
- 双重检测实现方式既支持延迟加载、又支持高并发的单例实现方式。只要 instance 被创建之后,再调用 getInstance() 函数都不会进入到加锁逻辑中。所以,这种实现方式解决了懒汉式并发度低的问题。
静态内部类
- 利用 Java 的静态内部类来实现单例。这种实现方式,既支持延迟加载,也支持高并发,实现起来也比双重检测简单。
枚举方式
- 最简单的实现方式,基于枚举类型的单例实现。这种实现方式通过 Java 枚举类型本身的特性,保证了实例创建的线程安全性和实例的唯一性(同时阻止了反射和序列化对单例的破坏)。