设计模式之单例模式

文章目录

• • 设计模式之单例模式
• 一、什么是单例模式？
• 二、单例模式的分类及实现
• • 1.饿汉式单例
  • 2.懒汉式单例
  • 3.静态内部类

---

一、什么是单例模式？

在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。

单例模式的定义

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

特点

1. 单例类只有一个实例对象；
2. 该单例对象必须由单例类自行创建；
3. 单例类对外提供一个访问该单例的全局访问点。

单例模式的优缺点
优点：

• 单例模式可以保证内存里只有一个实例，减少了内存的开销。
• 可以避免对资源的多重占用。
• 单例模式设置全局访问点，可以优化和共享资源的访问。

缺点：

• 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
• 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
• 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

二、单例模式的分类及实现

主要分为饿汉式和懒汉式

1.饿汉式单例

该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。

package Single;
//饿汉式单例
public class Hungry {
    //可能会浪费空间
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    private Hungry(){

    }
    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

2.懒汉式单例

为了避免被多次实例化，就将类中的构造函数限定为private，保证其他的程序无法通过new关键字来实例化，实现真正的单例

package Single;

//懒汉式单例
public class LazyMan(){
	
}
	private static LazyMan lazyMan;

	public static LazyMan getInstance(){
	if(lazyMan==null){
	lazyMan = new LazyMan();
	}
	return lazyMan;
}

上述是简单的懒汉式单例模式（单线程），但如果是多线程并发，就会出现问题，就需要加锁，需要做两次判断，会出现线程安全问题，一定保证LazyMan避免指令重排，必须加volatile

  private volatile static LazyMan LazyMan;

    //双重检测锁模式的  懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        //加锁
        if(LazyMan==null){
          synchronized (LazyMan.class){
              if(LazyMan==null){
                  LazyMan = new LazyMan();//不是一个原子性操作
				/*
				 * 1.分配内存空间
				 * 2.执行构造方法，初始化对象
				 * 3.把这个对象指向这个空间
				 * */
              }
          }
        }
       return LazyMan;//此时LayMan还没有完成构造
    }

3.静态内部类

package Single;

//静态内部类
public class Holder {
    private Holder(){

    }

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

综上所述，单例是不安全的，通过反射能破坏单例，枚举是jdk1.5就有的，存在有参构造，是不能被反射破环的。

标签：private,static,模式,单例,new,设计模式,LazyMan
来源： https://blog.csdn.net/TANGWENYU_/article/details/122309795