【嵌入式c++】设计模式之单例模式(Singleton)_嵌入式 设计模式单例模式

设计模式之单例模式(Singleton)

Singleton

动机(Motivation)

+ 在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性、以及良好的效率。

+ 如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例？

+ 这应该是类设计者的责任，而不是使用者的责任。

模式定义

保证一个类仅有一个实例，并提供一个该实例的全局访问点。

——《设计模式》GoF

要点总结

+ Singleton模式中的实例构造器可以设置为protected以允许子类派生。

+ Singleton模式一般不要支持拷贝构造函数和Clone接口，因为这有可能导致多个对象实例，与Singleton模式的初中违背。

+ 如何实现多线程环境下安全的Singleton？注意对双检查锁的正确实现。

代码结构 :

.
├── build.sh
├── clearBuild.sh
├── CMakeLists.txt
├── src 
│   ├── examStu.cpp
│   ├── include
│   │   └── examStu.h
│   └── main.cpp
1
2
3
4
5
6
7
8
9

源码例子 :

examStu.h

#ifndef _EXANSTU__
#define _EXANSTU__
#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Singleton{
private:
  Singleton();
  Singleton(const Singleton& other);
public:
  static Singleton& getInstance();
  static Singleton* m_instance;
};

Singleton* Singleton::m_instance=nullptr;
//线程非安全版本
Singleton* Singleton::getInstance() {
  if (m_instance == nullptr) {
​    m_instance = new Singleton();
  }
  return m_instance;
}

//线程安全版本，但锁的代价过高 ,每次调用都需要上锁消耗资源

Singleton* Singleton::getInstance() {
  Lock lock;
  if (m_instance == nullptr) 
  {
​    m_instance = new Singleton();
  }
  return m_instance;
}
//双检查锁，但由于内存读写reorder不安全
Singleton* Singleton::getInstance() {
  if(m_instance==nullptr){
​    Lock lock;
​    if (m_instance == nullptr) {
​      m_instance = new Singleton();
​    }
  }
  return m_instance;
}

//安全，但存储在静态存储区，浪费静态存储空间

Singleton* Singleton::getInstance() 
{
  static Singleton m_instance;
  return m_instance;
}
//C++ 11版本之后的跨平台实现 (volatile)
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;

Singleton* Singleton::getInstance() {
  Singleton* tmp = m_instance.load(std::memory_order_relaxed);
  std::atomic_thread_fence(std::memory_order_acquire);//获取内存fence
  if (tmp == nullptr) {
​    std::lock_guard<std::mutex> lock(m_mutex);
​    tmp = m_instance.load(std::memory_order_relaxed);
​    if (tmp == nullptr) {
​      tmp = new Singleton;
​      std::atomic_thread_fence(std::memory_order_release);//释放内存fence
​      m_instance.store(tmp, std::memory_order_relaxed);
​    }
  }

  return tmp;

}

class FaceMsgHandler
{
public:
  static std::shared_ptr<FaceMsgHandler> GetInstance();
  ~FaceMsgHandler();
private:
  static std::shared_ptr<FaceMsgHandler> pFaceMsgHandler;
  static pthread_once_t ponce_;
  static void Init(){
​    pFaceMsgHandler = std::shared_ptr<FaceMsgHandler>(new FaceMsgHandler);
  }
  FaceMsgHandler();
}; 

//双检查锁，但由于内存读写reorder不安全
std::shared_ptr<Singleton> Singleton::m_instance(nullptr);
std::mutex FaceMsgHandler::FaceMsgHandlerInstanceLock;
std::shared_ptr<Singleton> Singleton::GetInstance()
{

  if(nullptr == m_instance){
​    std::lock_guard<std::mutex> lck(SingletonLock);
​    if(nullptr == m_instance){      
​      m_instance = std::shared_ptr<Singleton>(new Singleton);

​    }
  }
  return m_instance;
}
//安全 保证Init函数只执行一次
std::shared_ptr<FaceMsgHandler> FaceMsgHandler::pFaceMsgHandler(nullptr);
pthread_once_t FaceMsgHandler::ponce_ = PTHREAD_ONCE_INIT;

std::shared_ptr<FaceMsgHandler> FaceMsgHandler::GetInstance()
{
  pthread_once(&ponce_,&FaceMsgHandler::Init);
  return pFaceMsgHandler;
}

#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115