第一个设计模式——单例模式

一、特点：

二、实现单例模式步骤

三、饿汉式

四、懒汉式

一、特点：

唯一性，单例模式确保程序中只有一个实例存在
节省内存开销，不用多次创建对象

二、实现单例模式步骤

私有化构造函数，防止外部实例化
提供公共获取单例对象的静态方法

三、饿汉式

饿汉式是什么？

指在类加载时就完成了初始化。

java实现

public class Singleton {
//创建一个静态的单例对象
private static final Singleton instance = new Singleton();

复制代码

  //私有化构造函数，防止外部实例化
  private Singleton(){}

  //提供公共的获取单例对象的静态方法
  public static Singleton getInstance(){
      return instance;
  }

}

kotlin实现

object Singleton {
//Kotlin的object关键字自动实现了饿汉式单例
}

优点：是线程安全的，因为JVM在进行类加载的时候，会进行加锁，每个类只有一份class对象，然后类加载的时候就会执行静态代码块、静态变量。

缺点：可能被反序列化和反射破坏、浪费资源，当你不需要单例实例，只想调用类中的静态方法时，它都会帮你执行静态代码块和静态变量，因为类加载。例如：

四、懒汉式

懒汉式是什么？

是指第一次调用时才初始化

1.不正确的懒汉式单例模式：

虽然最后打印的结果是一样的对象，这是只有主线程的情况，但是如果在多线程下呢？

java例子：

koltin例子：

可以看到如果在多线程下，该对象就会被创建多次，所以这种方法是不对的。

2.正确的懒汉式单例模式：

java实现

public class Singleton {
//创建一个静态的单例对象
private static Singleton instance = null;

复制代码

  //私有化构造函数，防止外部实例化
  private Singleton(){
      System.out.println("Singleton正在实例化");
  }

  //提供公共的获取单例对象的静态方法
  public synchronized static Singleton getInstance(){
      if(instance == null){
          instance = new Singleton();
      }
      return instance;
  }

}

kotlin 实现

class Singleton {
private constructor(){
println("Singleton正在被实例")
}

复制代码

  companion object{
      private var instance:Singleton? = null

      @Synchronized
      public fun  getInstance():Singleton{
          if(instance == null){
              instance = Singleton()
          }
          return instance!!
      }
  }

}

优点：在多线程下，能保证该类只实例一次。

缺点：可能被反序列化和反射破坏、为方法加锁，粒度太大，即锁定的范围过宽。这意味着锁保护的区域较大，包括了多个操作或整个方法，这会对系统的性能和并发能力产生一些负面影响，多个线程可能因为需要访问一个被锁定的方法而排队等待，导致线程资源的低效使用。

进行优化，减小锁的范围：

五、双重检查锁

java实现

public class Singleton {
//创建一个静态的单例对象
private volatile static Singleton instance = null;

复制代码

  //私有化构造函数，防止外部实例化
  private Singleton(){
      System.out.println("Singleton正在实例化");
  }

  //提供公共的获取单例对象的静态方法
  public  static Singleton getInstance(){
      if(instance == null){
          synchronized(Singleton.class) {
              if(instance == null) {
                  instance = new Singleton();
              }
          }
      }
      return instance;
  }

}

kotlin实现

class Singleton {
private constructor(){
println("Singleton正在被实例")
}

复制代码

  companion object{
      @Volatile
      private  var instance:Singleton? = null


      public fun  getInstance():Singleton{
          if(instance == null){
              synchronized(Singleton::class.java) {
                  if(instance == null) {
                      instance = Singleton()
                  }
              }
          }
          return instance!!
      }
  }

}

优点：线程安全、提高了性能、避免了资源浪费。

缺点：可能被反序列化和反射破坏、结构复杂，要记得加volatile关键字。

六、静态内部类

java实现

public class Singleton {

复制代码

  //私有化构造函数，防止外部实例化
  private Singleton(){
      System.out.println("Singleton正在实例化");
  }

  // 静态内部类，只有在第一次被访问时才会被加载
  private static class SingletonHolder {
      private static final Singleton INSTANCE = new Singleton();
  }

  public static Singleton getInstance() {
      return SingletonHolder.INSTANCE;
  }

}

kotlin实现

class Singleton {
private constructor(){
println("Singleton正在被实例")
}

复制代码

  companion object{
      object SingletonHolder{
          val INSTANCE = Singleton()
      }
      
      public fun getInstance():Singleton{
          return SingletonHolder.INSTANCE
      }
  }

}

优点：线程安全、避免了资源浪费、实现简单

缺点：可能被反序列化和反射破坏、它的线程安全是依靠类加载，但是类加载是耗性能的，类加载的过程：