add singleton for c

Author: Jarry

.vscode/settings.json

@@ -36,6 +36,8 @@
     "iosfwd": "c",
     "locale": "c",
     "*.tcc": "c",
-    "system_error": "c"
+    "system_error": "c",
+    "__mutex_base": "c",
+    "mutex": "c"
   }
 }

singleton-pattern/c/src/eager_singleton.c

@@ -0,0 +1,24 @@
+#include "func.h"
+
+void eager_singleton_run(EagerSingleton *singleton)
+{
+  printf("\r\n EagerSingleton::run() [name=%s value=%d]", singleton->name, singleton->value);
+}
+
+// 直接用static声明struct对象并初始化，相当于实例化类
+static EagerSingleton earge_singleton_instance = {
+    .name = "",
+    .run = &eager_singleton_run,
+    .value = 0,
+};
+
+// 饿汉模式，全局唯一，系统加载则初始化变量，无并发安全问题，但可能存在浪费
+EagerSingleton *get_eager_singleton_instance(char *name)
+{
+  // 如果name为空则更新name
+  if (strcmp(earge_singleton_instance.name, "") == 0)
+  {
+    strcpy(earge_singleton_instance.name, name);
+  }
+  return &earge_singleton_instance;
+}

singleton-pattern/c/src/func.h

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+// 懒汉模式，不重复实例化，非线程安全
+typedef struct LazySingleton LazySingleton;
+typedef struct LazySingleton
+{
+  char name[50];
+  int value;
+  void (*run)(LazySingleton *);
+} LazySingleton;
+
+LazySingleton *get_lazy_singleton_instance();
+
+// 懒汉模式，加锁，线程安全
+typedef struct LazySingletonSafe LazySingletonSafe;
+typedef struct LazySingletonSafe
+{
+  char name[50];
+  int value;
+  void (*run)(LazySingletonSafe *);
+} LazySingletonSafe;
+LazySingletonSafe *get_lazy_singleton_safe_instance();
+
+// 懒汉模式，加锁，线程安全
+typedef struct EagerSingleton EagerSingleton;
+typedef struct EagerSingleton
+{
+  char name[50];
+  int value;
+  void (*run)(EagerSingleton *);
+} EagerSingleton;
+EagerSingleton *get_eager_singleton_instance();
+
+// 懒汉模式，加锁，增加volatile
+typedef struct LazySingletonVolatile LazySingletonVolatile;
+typedef struct LazySingletonVolatile
+{
+  char name[50];
+  int value;
+  void (*run)(LazySingletonVolatile *);
+} LazySingletonVolatile;
+LazySingletonVolatile *get_lazy_singleton_volatile_instance();

singleton-pattern/c/src/lazy_singleton.c

@@ -0,0 +1,24 @@
+#include "func.h"
+
+// 静态指针，未被创建并分配内存空间，指向唯一实例
+static LazySingleton *lazy_singleton_instance = NULL;
+
+void lazy_singleton_run(LazySingleton *singleton)
+{
+  printf("\r\n LazySingleton::run() [name=%s value=%d]", singleton->name, singleton->value);
+}
+
+// 非线程安全懒汉模式，延迟初始化。多个线程同时调用函数时， 可能会被初始化多次，存在线程不安全问题
+LazySingleton *get_lazy_singleton_instance(char *name)
+{
+  printf("\r\n get_lazy_singleton_instance() [name=%s]", name);
+  // 外部的实例，如果不存在则初始化，否则直接返回实例
+  if (lazy_singleton_instance == NULL)
+  {
+    printf("\r\n new instance [name=%s]", name);
+    lazy_singleton_instance = (LazySingleton *)malloc(sizeof(LazySingleton));
+    strcpy(lazy_singleton_instance->name, name);
+    lazy_singleton_instance->run = &lazy_singleton_run;
+  }
+  return lazy_singleton_instance;
+}

singleton-pattern/c/src/lazy_singleton_ volatile.c

@@ -0,0 +1,54 @@
+#include "func.h"
+#include <pthread.h>
+
+// 静态指针，未被创建并分配内存空间，指向唯一实例
+static LazySingletonVolatile *lazy_singleton_volatile_instance = NULL;
+
+void lazy_singleton_volatile_run(LazySingletonVolatile *singleton)
+{
+  printf("\r\n LazySingletonVolatile::run() [name=%s value=%d]", singleton->name, singleton->value);
+}
+
+// 内部私有实例化函数，不公开
+static LazySingletonVolatile *new_lazy_singleton_volatile(char *name)
+{
+  LazySingletonVolatile *singleton = (LazySingletonVolatile *)malloc(sizeof(LazySingletonVolatile));
+  strcpy(singleton->name, name);
+  singleton->run = &lazy_singleton_volatile_run;
+  return singleton;
+}
+
+static inline void rmb()
+{
+  asm volatile("lfence");
+}
+
+static inline void wmb()
+{
+  asm volatile("sfence");
+}
+
+// 声明锁
+pthread_mutex_t singleton_lock;
+
+// 非线程安全懒汉模式，延迟初始化。多个线程同时调用函数时， 可能会被初始化多次，存在线程不安全问题
+LazySingletonVolatile *get_lazy_singleton_volatile_instance(char *name)
+{
+  printf("\r\n get_lazy_singleton_volatile_instance() [name=%s]", name);
+  if (pthread_mutex_init(&singleton_lock, NULL) != 0)
+  {
+    perror("error init mutext:");
+  }
+
+  // 通过加锁和volatile双重机制来防止线程并发导致安全隐患
+  if (lazy_singleton_volatile_instance == NULL)
+  {
+    printf("\r\n new instance [name=%s]", name);
+    pthread_mutex_lock(&singleton_lock);
+    rmb();
+    lazy_singleton_volatile_instance = new_lazy_singleton_volatile(name);
+    wmb();
+    pthread_mutex_unlock(&singleton_lock);
+  }
+  return lazy_singleton_volatile_instance;
+}

singleton-pattern/c/src/lazy_singleton_safe.c

@@ -0,0 +1,42 @@
+#include "func.h"
+#include <pthread.h>
+
+// 静态指针，未被创建并分配内存空间，指向唯一实例
+static LazySingletonSafe *lazy_singleton_safe_instance = NULL;
+
+void lazy_singleton_safe_run(LazySingletonSafe *singleton)
+{
+  printf("\r\n LazySingletonSafe::run() [name=%s value=%d]", singleton->name, singleton->value);
+}
+
+// 内部私有实例化函数，不公开
+static LazySingletonSafe *new_lazy_singleton_safe(char *name)
+{
+  LazySingletonSafe *singleton = (LazySingletonSafe *)malloc(sizeof(LazySingletonSafe));
+  strcpy(singleton->name, name);
+  singleton->run = &lazy_singleton_safe_run;
+  return singleton;
+}
+
+// 声明锁
+pthread_mutex_t singleton_lock;
+
+// 非线程安全懒汉模式，延迟初始化。多个线程同时调用函数时， 可能会被初始化多次，存在线程不安全问题
+LazySingletonSafe *get_lazy_singleton_safe_instance(char *name)
+{
+  printf("\r\n get_lazy_singleton_safe_instance() [name=%s]", name);
+  if (pthread_mutex_init(&singleton_lock, NULL) != 0)
+  {
+    perror("error init mutext:");
+  }
+
+  // 通过加锁来防止线程并发导致的不安全
+  if (lazy_singleton_safe_instance == NULL)
+  {
+    printf("\r\n new instance [name=%s]", name);
+    pthread_mutex_lock(&singleton_lock);
+    lazy_singleton_safe_instance = new_lazy_singleton_safe(name);
+    pthread_mutex_unlock(&singleton_lock);
+  }
+  return lazy_singleton_safe_instance;
+}

singleton-pattern/c/test/test.c

@@ -0,0 +1,55 @@
+#include "../src/func.h"
+
+int main(void)
+{
+  printf("test start:\r\n");
+  /**
+   * 单例模式就是一个类只创建一个实例，以便节省开销和保证统一
+   * 对于多线程语言需要注意线程安全和性能之间取得一个平衡
+   */
+
+  // 懒汉模式，调用函数时实例化
+  LazySingleton *lazy_singleton1 = get_lazy_singleton_instance("lazySingleton1");
+  LazySingleton *lazy_singleton2 = get_lazy_singleton_instance("lazySingleton2");
+  lazy_singleton1->run(lazy_singleton1);
+  // 实例相同
+  lazy_singleton2->value = 99;
+  lazy_singleton2->run(lazy_singleton2);
+
+  // 懒汉模式，线程安全
+  LazySingletonSafe *lazy_singleton_safe1 = get_lazy_singleton_safe_instance("lazySingletonSafe1");
+  LazySingletonSafe *lazy_singleton_safe2 = get_lazy_singleton_safe_instance("lazySingletonSafe2");
+  lazy_singleton_safe1->run(lazy_singleton_safe1);
+  // 实例相同
+  lazy_singleton_safe2->value = 88;
+  lazy_singleton_safe2->run(lazy_singleton_safe2);
+
+  // 懒汉模式volatile，线程安全
+  LazySingletonVolatile *lazy_singleton_volatile1 = get_lazy_singleton_volatile_instance("lazySingletonVolatile1");
+  LazySingletonVolatile *lazy_singleton_volatile2 = get_lazy_singleton_volatile_instance("lazySingletonVolatile2");
+  lazy_singleton_volatile1->run(lazy_singleton_volatile1);
+  // 实例相同
+  lazy_singleton_volatile2->value = 77;
+  lazy_singleton_volatile2->run(lazy_singleton_volatile2);
+
+  // 饿汉模式，已经初始化，可直接使用
+  EagerSingleton *eager_singleton1 = get_eager_singleton_instance("eagerSingleton1");
+  EagerSingleton *eager_singleton2 = get_eager_singleton_instance("eagerSingleton2");
+  eager_singleton1->run(eager_singleton1);
+  // 实例相同
+  eager_singleton2->run(eager_singleton2);
+}
+
+/**
+jarry@jarrys-MacBook-Pro c % gcc test/test.c ./src下*.c
+jarry@jarrys-MacBook-Pro c % ./a.out
+test start:
+
+ proxy_image_constructor() [构建ProxyImage]
+ ProxyImage::display() [file_name=001.jpg]
+ real_image_constructor() [构建RealImage]
+ RealImage::load_from_disk() [file_name=001.jpg]
+ RealImage::display() [file_name=001.jpg]
+ ProxyImage::display() [file_name=001.jpg]
+ RealImage::display() [file_name=001.jpg]%
+ */

singleton-pattern/go/src/SingletonInterface.go

@@ -27,7 +27,7 @@ var (
 	syncOnce sync.Once
 )
 
-// 条用GetInstance返回SingletonInterface对象
+// 利用GetInstance返回SingletonInterface对象
 func GetSingletonInterface(name string) SingletonInterface {
 	// 利用sync.Once来实现一次实例化
 	syncOnce.Do(func() {

singleton-pattern/js/src/EagerSingleton.js

@@ -0,0 +1,20 @@
+export class EagerSingleton {
+  constructor(alias) {
+    this.alias = alias
+  }
+
+  // 饿汉模式，直接返回已经初始化的实例
+  static getInstance(alias) {
+    if (this.instance.alias === undefined || this.instance.alias === '') {
+      this.instance.alias = alias
+    }
+    return this.instance
+  }
+
+  run() {
+    console.log('EagerSingleton::run()', EagerSingleton.instance.alias)
+  }
+}
+
+// 直接初始化
+EagerSingleton.instance = new EagerSingleton('')

singleton-pattern/js/src/LazySingleton.js

@@ -0,0 +1,19 @@
+export class LazySingleton {
+  static instance
+  constructor(alias) {
+    this.alias = alias
+  }
+
+  // 懒汉模式，延迟实例化，请求实例时判断，如果已经实例化过就直接返回
+  // js是单线程语言，无需考虑多线程问题
+  static getInstance(alias) {
+    if (this.instance === undefined) {
+      this.instance = new LazySingleton(alias)
+    }
+    return this.instance
+  }
+
+  run() {
+    console.log('LazySingleton::run()', this.alias)
+  }
+}

singleton-pattern/js/src/SingleObject.js singleton-pattern/js/src/LazySingletonObject.js

@@ -1,25 +1,26 @@
-export const SingleObject = (function () {
+export const LazySingletonObject = (function () {
   let instance
-
-  // 对象创建方式，如果已经实例化则直接返回对象，类似一个普通Object
+  // 创建对象，不是class，无需实例化，直接返回对象
   function createInstance(alias) {
     if (instance) {
       return instance
     }
     instance = Object.create(null)
     instance.alias = alias
     instance.run = function () {
-      console.log('SingleObject::()', instance.alias)
+      console.log('LazySingletonObject::run()', instance.alias)
     }
     return instance
   }
 
   return {
+    // 通过函数来获得实例，延迟初始化
+    // 也可以直接执行函数，则立即初始化
     getInstance: function (alias) {
       if (!instance) {
         instance = createInstance(alias)
       }
       return instance
-    },
+    }
   }
 })()