add go for singleton

Author: jarry

singleton-pattern/go/src/DoubleCheckSingleton.go

@@ -0,0 +1,35 @@
+package src
+
+import (
+  "fmt"
+  "sync"
+)
+
+// 安全懒汉模式的升级版，通过sync的Mutex实现双重检验
+type DoubleCheckSingleton struct {
+  name string
+}
+
+func (s *DoubleCheckSingleton) Run() {
+  fmt.Println("DoubleCheckSingleton::run()", s.name)
+}
+
+// 定义私有变量，用来保存实例
+var doubleCheckSingletonInstance *DoubleCheckSingleton
+var lock = &sync.Mutex{}
+
+// 是懒汉模式安升级版，双重检查来来支持延迟实例化单例对象
+func GetDoubleCheckSingletonInstance(name string) *DoubleCheckSingleton {
+  // 未实例化才进行加锁
+  if doubleCheckSingletonInstance == nil {
+    lock.Lock()
+    defer lock.Unlock()
+    // 为了保险，锁住之后再次检查是否已实例化
+    if doubleCheckSingletonInstance == nil {
+      doubleCheckSingletonInstance = &DoubleCheckSingleton{}
+      doubleCheckSingletonInstance.name = name
+    }
+  }
+
+  return doubleCheckSingletonInstance
+}

singleton-pattern/go/src/EagerSingleton.go

@@ -0,0 +1,29 @@
+package src
+
+import "fmt"
+
+// 饿汉模式单例
+type EagerSingleton struct {
+  name string
+}
+
+func (s *EagerSingleton) Run() {
+  fmt.Println("EagerSingleton::run()", s.name)
+}
+
+// 定义私有变量，用来保存实例
+var eagerSingletonInstance *EagerSingleton
+
+// 由主程序在初始化时执行，让实例保存在内存中，这样将获得唯一值
+func EagerSingletonInit() {
+  eagerSingletonInstance = new(EagerSingleton)
+  // eagerSingletonInstance = &EagerSingleton{}
+}
+
+func GetEagerSingleton(name string) *EagerSingleton {
+  // 如果name为空则赋值，已经赋值过了说明已经实例化了
+  if eagerSingletonInstance.name == "" {
+    eagerSingletonInstance.name = name
+  }
+  return eagerSingletonInstance
+}

singleton-pattern/go/src/LazySingleton.go

@@ -0,0 +1,25 @@
+package src
+
+import "fmt"
+
+// 懒汉模式单例，延迟实例化，但不是很安全
+type LazySingleton struct {
+  name string
+}
+
+func (s *LazySingleton) Run() {
+  fmt.Println("LazySingleton::run()", s.name)
+}
+
+// 定义私有变量
+var lazySingleton *LazySingleton
+
+// Golang不支持静态方法，可用外部func代替
+func GetLazySingletonInstance(name string) *LazySingleton {
+  // 并发很多情况下，不同线程可能会创建多个实例
+  if lazySingleton == nil {
+    lazySingleton = &LazySingleton{}
+    lazySingleton.name = name
+  }
+  return lazySingleton
+}

singleton-pattern/go/src/LazySingletonSafe.go

@@ -0,0 +1,31 @@
+package src
+
+import (
+  "fmt"
+  "sync"
+)
+
+// 懒汉模式单例，延迟实例化，导入sync包，利用once来提升安全
+type LazySingletonSafe struct {
+  name string
+}
+
+func (s *LazySingletonSafe) Run() {
+  fmt.Println("LazySingletonSafe::run()", s.name)
+}
+
+// 定义私有变量
+var lazySingletonSafeInstance *LazySingletonSafe
+var once = &sync.Once{}
+
+// 外部函数，用来实例化类
+func GetLazySingletonSafeInstance(name string) *LazySingletonSafe {
+  if lazySingletonSafeInstance == nil {
+    // 通过原子操作判断是否执行过来保证并发时的线程安全
+    once.Do(func() {
+      lazySingletonSafeInstance = &LazySingletonSafe{}
+      lazySingletonSafeInstance.name = name
+    })
+  }
+  return lazySingletonSafeInstance
+}

singleton-pattern/go/src/go.mod

@@ -0,0 +1,3 @@
+module src
+
+go 1.15

singleton-pattern/go/test/test.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+  "fmt"
+
+  "../src"
+)
+
+// main包下的main入口方法
+func main() {
+  fmt.Println("test start:")
+  /**
+   * 单例模式就是一个类只创建一个实例，以便节省开销和保证统一
+   * 对于多线程语言需要注意线程安全和性能之间取得一个平衡
+   */
+
+  // 懒汉模式，调用函数时实例化
+  var lazySingleton1 = src.GetLazySingletonInstance("lazySingleton1")
+  var lazySingleton2 = src.GetLazySingletonInstance("lazySingleton2")
+  lazySingleton1.Run()
+  // 实例相同
+  lazySingleton2.Run()
+
+  // 懒汉模式，线程安全
+  var lazySingletonSafe1 = src.GetLazySingletonSafeInstance("lazySingletonSafe1")
+  lazySingletonSafe2 := src.GetLazySingletonSafeInstance("lazySingletonSafe2")
+  lazySingletonSafe1.Run()
+  // 实例相同
+  lazySingletonSafe2.Run()
+
+  // 双重检查机制，并发加锁
+  var doubleCheckSingleton1 = src.GetDoubleCheckSingletonInstance("doubleCheckSingleton1")
+  doubleCheckSingleton2 := src.GetDoubleCheckSingletonInstance("doubleCheckSingleton2")
+  doubleCheckSingleton1.Run()
+  // 实例相同
+  doubleCheckSingleton2.Run()
+
+  // 饿汉模式，在main里直接初始化，这样就可以获得唯一实例
+  src.EagerSingletonInit()
+  var eagerSingleton1 = src.GetEagerSingleton("eagerSingleton1")
+  var eagerSingleton2 = src.GetEagerSingleton("eagerSingleton2")
+  eagerSingleton1.Run()
+  // 实例相同
+  eagerSingleton2.Run()
+}
+
+/**
+jarry@jarrys-MacBook-Pro go % go build src/*.go
+jarry@jarrys-MacBook-Pro go % go run test/test.go
+test start:
+LazySingleton::run() lazySingleton1
+LazySingleton::run() lazySingleton1
+LazySingletonSafe::run() lazySingletonSafe1
+LazySingletonSafe::run() lazySingletonSafe1
+DoubleCheckSingleton::run() doubleCheckSingleton1
+DoubleCheckSingleton::run() doubleCheckSingleton1
+EagerSingleton::run() eagerSingleton1
+EagerSingleton::run() eagerSingleton1
+*/

singleton-pattern/java/src/SingleObject.java

@@ -0,0 +1,32 @@
+package src;
+
+// 双重检验懒汉单例，单例模式最优方案，线程安全并且效率高 
+public class SingletonDoubleCheck {
+
+  // 定义一个静态私有变量(不初始化，不使用final关键字）
+  // 可以使用volatile保证多线程访问时变量的可见性
+  // 这样避免了初始化时其他变量属性还没赋值完时，被另外线程调用
+  private static volatile SingletonDoubleCheck instance;
+  private String name;
+  private SingletonDoubleCheck() {
+
+  }
+
+  // 延迟到调用时实例化
+  public static SingletonDoubleCheck getInstance(String name) {
+    if (instance == null) {
+      // 在实例化时再synchronized
+      synchronized (SingletonDoubleCheck.class) {
+        if (instance == null) {
+          instance = new SingletonDoubleCheck();
+          instance.name = name;
+        }
+      }
+    }
+    return instance;
+  }
+
+  public void run() {
+    System.out.println("SingletonDoubleCheck::run() " + this.name);
+  }
+}

singleton-pattern/java/src/SingletonDoubleCheck.java

@@ -0,0 +1,21 @@
+package src;
+
+// 饿汉式（线程安全）
+// 当类被加载的时候会初始化，静态变量被创建并分配内存空间 
+public class SingletonEager {
+  private String name = "SingletonEager";
+  // 类加载时就初始化，浪费内存
+  private static final SingletonEager instance = new SingletonEager();
+
+  // 构造函数是private，不允许实例化
+  private SingletonEager() {
+
+  }
+  public static SingletonEager getInstance() {
+    return instance;
+  }
+
+  public void run() {
+    System.out.println("SingletonEager::run() " + this.name);
+  }
+}

singleton-pattern/java/src/SingletonEager.java

@@ -1,20 +1,29 @@
 package src;
 
+// 静态内部类方式，既实现延迟加载，也保障线程安全。
 public class SingletonInner {
 
+  private String name;
+
   private SingletonInner() {
 
   }
 
+  // 静态内部类利用了类加载初始化机制，外部类加载时，并不会加载内部类，也不会执行
+  // 虚拟机会保证方法在多线程环境下使用加锁同步，只会执行一次，因此线程安全
   private static class Inner {
-    private static final SingletonInner instance = new SingletonInner();  
+    private static final SingletonInner instance = new SingletonInner();
   }
 
-  public static SingletonInner getInstance() {
+  // 当执行getInstance()方法时，虚拟机才会加载静态内部类
+  public static SingletonInner getInstance(String name) {
+    if (Inner.instance.name == null) {
+      Inner.instance.name = name;
+    }
     return Inner.instance;
   }
 
   public void run() {
-    System.out.println("SingletonInner::run()");
+    System.out.println("SingletonInner::run() " + this.name);
   }
 }

singleton-pattern/java/src/SingletonInner.java

@@ -1,22 +1,27 @@
 package src;
 
+// 懒汉式也叫饱汉式，增加synchronized来保证线程安全
 public class SingletonLazy {
 
   private static SingletonLazy instance;
+  private String name;
 
   private SingletonLazy() {
 
   }
 
-  // 延迟到调用时实例化，加synchronized以便线程安全
-  public static synchronized SingletonLazy getInstance() {
+  // 类初始化时，静态变量static的instance未被创建并分配内存空间
+  // 当getInstance方法第一次被调用时，再初始化instance变量，并分配内存
+  // 相当于延迟到调用时再实例化，加synchronized以便线程安全，不加则存在并发时多个实例的情形
+  public static synchronized SingletonLazy getInstance(String name) {
     if (instance == null) {
       instance = new SingletonLazy();
+      instance.name = name;
     }
     return instance;
   }
 
   public void run() {
-    System.out.println("SingletonLazy::run()");
+    System.out.println("SingletonLazy::run() " + this.name);
   }
 }