单例模式与全局唯一id的思考----c++ ，c ，python 实现

前段时间去考了系统架构师，排错题基本全是设计模式的内容。设计模式真的这么重要么？答案是肯定的，没有设计模式就没有现在复杂的软件系统。

于是，我想要慢慢的花两个月时间，重拾语言关，再者c++的设计模式网上实现比较少，我就来帮助大家搜集一下，当然实现方式还是我喜欢的c，c++，python三种语言分别实现。

Christopher Alexander 说过：“每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心，这样，你就能一次又一次地使用该方案而不必做重复劳动。”第一个设计模式，我选择单例模式

1.设计模式纵览

1、单一职责原则（Single Responsibility Principle）

就一个类而言，应该仅有一个引起它变化的原因。一个类只做一件事。

2、开闭原则（Open Close Principle）

对扩展开放，对修改关闭。

3、里氏代换原则（Liskov Substitution Principle）

任何基类可以出现的地方，子类一定可以出现。

4、依赖倒转原则（Dependence Inversion Principle）

真对接口编程，依赖于抽象而不依赖于具体。

5、接口隔离原则（Interface Segregation Principle）

使用多个隔离的接口，比使用单个接口要好。

6、迪米特法则（最少知道原则）（Demeter Principle）

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

2.单例模式应该考虑线程安全!

单例模式的应用场景

有很多地方需要单例模式这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。

通过单例模式， 可以做到：

（1）确保一个类只有一个实例被建立

（2）提供了一个对对象的全局访问指针

（3）在不影响单例类的客户端的情况下允许将来有多个实例

2.1 教科书里的单例模式

我们都很清楚一个简单的单例模式该怎样去实现：构造函数声明为private或protect防止被外部函数实例化，内部保存一个private static的类指针保存唯一的实例，实例的动作由一个public的类方法代劳，该方法也返回单例类唯一的实例。

上代码：

class singleton
{
protected:
singleton(){}
private:
static singleton* p;
public:
static singleton* instance();
};

singleton* singleton::p = NULL;

singleton* singleton::instance()
{
if (p == NULL)
p = new singleton();
return p;
}

这是一个很棒的实现，简单易懂。但这是一个完美的实现吗？不！该方法是线程不安全的，考虑两个线程同时首次调用instance方法且同时检测到p是NULL值，则两个线程会同时构造一个实例给p，这是严重的错误！同时，这也不是单例的唯一实现！

2.2 懒汉与饿汉

单例大约有两种实现方法：懒汉与饿汉。

懒汉：故名思义，不到万不得已就不会去实例化类，也就是说在第一次用到类实例的时候才会去实例化，所以上边的经典方法被归为懒汉实现；

饿汉：饿了肯定要饥不择食。所以在单例类定义的时候就进行实例化。

特点与选择：

由于要进行线程同步，所以在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。

在访问量较小时，采用懒汉实现。这是以时间换空间。

2.3 线程安全的懒汉实现

线程不安全，怎么办呢？最直观的方法：加锁。访问量大有可能成为严重的性能瓶颈

方法1：

加锁的经典懒汉实现：

class singleton
{
protected:
singleton() {}
private:
static singleton* p;
public:
static pthread_mutex_t mutex;
static singleton* initance();
};

pthread_mutex_t singleton::mutex;
singleton* singleton::p = NULL;

singleton* singleton::initance()
{
if (p == NULL)
{
pthread_mutex_lock(&mutex);
if (p == NULL)
p = new singleton();
pthread_mutex_unlock(&mutex);
}
return p;
}

方法2：内部静态变量的懒汉实现

此方法也很容易实现，在instance函数里定义一个静态的实例，也可以保证拥有唯一实例，在返回时只需要返回其指针就可以了。推荐这种实现方法，真得非常简单。

class singleton
{
protected:
singleton()
{
pthread_mutex_init(&mutex);
}
public:
static pthread_mutex_t mutex;
static singleton* initance();
int a;
};

pthread_mutex_t singleton::mutex;

singleton* singleton::initance()
{
pthread_mutex_lock(&mutex);
static singleton obj;
pthread_mutex_unlock(&mutex);
return &obj;
}

4 饿汉实现

为什么我不讲“线程安全的饿汉实现”？因为饿汉实现本来就是线程安全的，不用加锁。为啥？自己想！

class singleton
{
protected:
singleton()  {}
private:
static singleton* p;
public:
static singleton* initance();
};

singleton* singleton::p = new singleton;

singleton* singleton::initance()
{
return p;
}

是不是特别简单呢？以空间换时间，你说简单不简单？

面试的时候，线程安全的单例模式怎么写？肯定怎么简单怎么写呀！饿汉模式反而最懒！　

windows 下这么写：

#include "stdafx.h"

using namespace std;

class SingletonStatic
{
private:
static const SingletonStatic* m_instance;
SingletonStatic() {}

public:
static const SingletonStatic* getInstance()
{
return m_instance;
}
};

//外部初始化 before invoke main
const SingletonStatic* SingletonStatic::m_instance = new SingletonStatic;

int main()
{
const SingletonStatic* temp_instance = SingletonStatic::getInstance();
return 0;
}

单例的析构

C++单例模式类CSingleton有以下特征：

它有一个指唯一实例的静态指针m_pInstance，并且是私有的。

它有一个公有的函数，可以获取这个唯一的实例，并在需要的时候创建该实例。

它的构造函数是私有的，这样就不能从别处创建该类的实例。

大多时候，这样的实现都不会出现问题。有经验的读者可能会问，m_pInstance指向的空间什么时候释放呢？更严重的问题是，这个实例的析构操作什么时候执行？

如果在类的析构行为中有必须的操作，比如关闭文件，释放外部资源，那么上面所示的代码无法实现这个要求。我们需要一种方法，正常地删除该实例。

可以在程序结束时调用GetInstance并对返回的指针调用delete操作。这样做可以实现功能，但是不仅很丑陋，而且容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。

一个妥善的方法是让这个类自己知道在合适的时候把自己删除。或者说把删除自己的操作挂在系统中的某个合适的点上，使其在恰当的时候自动被执行。

我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。如下面的代码中的CGarbo类（Garbo意为垃圾工人）：

class CSingleton:
{
// 其它成员
public:
static CSingleton * GetInstance()
private:
CSingleton(){};
static CSingleton * m_pInstance;
class CGarbo // 它的唯一工作就是在析构函数中删除CSingleton的实例
{
public:
~CGarbo()
{
if (CSingleton::m_pInstance)
delete CSingleton::m_pInstance;
}
};
static CGarbo Garbo; // 定义一个静态成员，在程序结束时，系统会调用它的析构函数
};

类CGarbo被定义为CSingleton的私有内嵌类，以防该类被在其它地方滥用。

在程序运行结束时，系统会调用CSingleton的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。

使用这种方法释放C++单例模式对象有以下特征：

在单例类内部定义专有的嵌套类。

在单例类内定义私有的专门用于释放的静态成员。

利用程序在结束时析构全局变量的特性，选择最终的释放时机。

使用C++单例模式的代码不需要任何操作，不必关心对象的释放

c++11中的单例模式

使用c++11中的可变参数模版完成通用的单例模式

http://www.cnblogs.com/qicosmos/p/3145019.html

3.python需要单例么？

python2和python3的运行结果还有差异

#-*- encoding=utf-8 -*-

'''
date = 20171127
Singleton pattern
'''
###经典单例模式的实现
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls,'_instance'):
org = super(Singleton,cls)
cls._instance = org.__new__(cls)#cls,*args,**kwargs)
return cls._instance

#############################################################
class Singleton2(type):
def __init__(cls,name,bases,dict):
super(Singleton2, cls).__init__(name,bases,dict)
cls._instance = None
def __call__(cls  , *args, **kwargs):
if cls._instance is None:
cls._instance = super(Singleton2,cls).__call__(*args,**kwargs)
return cls._instance

class Myclass(object):
__metaclass__ = Singleton2

one = Myclass()
two = Myclass()

print(id(one))
print(id(two))

###############################################
def singleton3(cls, *args, **kw):
instances = {}
def _singleton():
if cls not in instances:
instances[cls] = cls(*args, **kw)
return instances[cls]
return _singleton

@singleton3
class Myclass2(object):
a = 1
def __init__(self, x=0):
self.x = x

three = Myclass2()
four = Myclass2()

print(id(three))
print(id(four))

#######################################

if __name__=='__main__':
class SingleSpam(Singleton):
def __init__(self,s):
self.s = s

def __str__(self):
return self.s

s1 = SingleSpam('shiter')
print( id(s1),s1)
s2 = SingleSpam('wynshiter')
print(id(s2), s2)

python3运行结果



python2运行结果

4.c语言设计模式也存在吗？

讨论帖子：

http://bbs.csdn.net/topics/392290682

zookeeper分布式协调服务

分布式系统唯一ID生成方案汇总（下一篇）

1. 数据库自增长序列或字段

最常见的方式。利用数据库，全数据库唯一。

优点：

1）简单，代码方便，性能可以接受。

2）数字ID天然排序，对分页或者需要排序的结果很有帮助。

缺点：

1）不同数据库语法和实现不同，数据库迁移的时候或多数据库版本支持的时候需要处理。

2）在单个数据库或读写分离或一主多从的情况下，只有一个主库可以生成。有单点故障的风险。

3）在性能达不到要求的情况下，比较难于扩展。

4）如果遇见多个系统需要合并或者涉及到数据迁移会相当痛苦。

5）分表分库的时候会有麻烦。

优化方案：

1）针对主库单点，如果有多个Master库，则每个Master库设置的起始数字不一样，步长一样，可以是Master的个数。比如：Master1 生成的是 1，4，7，10，Master2生成的是2,5,8,11 Master3生成的是 3,6,9,12。这样就可以有效生成集群中的唯一ID，也可以大大降低ID生成数据库操作的负载。

2. UUID

常见的方式。可以利用数据库也可以利用程序生成，一般来说全球唯一。

优点：

1）简单，代码方便。

2）生成ID性能非常好，基本不会有性能问题。

3）全球唯一，在遇见数据迁移，系统数据合并，或者数据库变更等情况下，可以从容应对。

缺点：

1）没有排序，无法保证趋势递增。

2）UUID往往是使用字符串存储，查询的效率比较低。

3）存储空间比较大，如果是海量数据库，就需要考虑存储量的问题。

4）传输数据量大

5）不可读。

UUID的变种

1）为了解决UUID不可读，可以使用UUID to Int64的方法。及

///

/// 根据GUID获取唯一数字序列

///

public static long GuidToInt64()

{

byte[] bytes = Guid.NewGuid().ToByteArray();

return BitConverter.ToInt64(bytes, 0);

}

1

2）为了解决UUID无序的问题，NHibernate在其主键生成方式中提供了Comb算法（combined guid/timestamp）。保留GUID的10个字节，用另6个字节表示GUID生成的时间（DateTime）。

///

/// Generate a new using the comb algorithm.

///

private Guid GenerateComb()

{

byte[] guidArray = Guid.NewGuid().ToByteArray();

DateTime baseDate = new DateTime(1900, 1, 1);
DateTime now = DateTime.Now;

// Get the days and milliseconds which will be used to build
//the byte string
TimeSpan days = new TimeSpan(now.Ticks - baseDate.Ticks);
TimeSpan msecs = now.TimeOfDay;

// Convert to a byte array
// Note that SQL Server is accurate to 1/300th of a
// millisecond so we divide by 3.333333
byte[] daysArray = BitConverter.GetBytes(days.Days);
byte[] msecsArray = BitConverter.GetBytes((long)
(msecs.TotalMilliseconds / 3.333333));

// Reverse the bytes to match SQL Servers ordering
Array.Reverse(daysArray);
Array.Reverse(msecsArray);

// Copy the bytes into the guid
Array.Copy(daysArray, daysArray.Length - 2, guidArray,
guidArray.Length - 6, 2);
Array.Copy(msecsArray, msecsArray.Length - 4, guidArray,
guidArray.Length - 4, 4);

return new Guid(guidArray);

}

用上面的算法测试一下，得到如下的结果：作为比较，前面3个是使用COMB算法得出的结果，最后12个字符串是时间序（统一毫秒生成的3个UUID），过段时间如果再次生成，则12个字符串会比图示的要大。后面3个是直接生成的GUID。

如果想把时间序放在前面，可以生成后改变12个字符串的位置，也可以修改算法类的最后两个Array.Copy。

4. Redis生成ID

当使用数据库来生成ID性能不够要求的时候，我们可以尝试使用Redis来生成ID。这主要依赖于Redis是单线程的，所以也可以用生成全局唯一的ID。可以用Redis的原子操作 INCR和INCRBY来实现。

可以使用Redis集群来获取更高的吞吐量。假如一个集群中有5台Redis。可以初始化每台Redis的值分别是1,2,3,4,5，然后步长都是5。各个Redis生成的ID为：

A：1,6,11,16,21

B：2,7,12,17,22

C：3,8,13,18,23

D：4,9,14,19,24

E：5,10,15,20,25

这个，随便负载到哪个机确定好，未来很难做修改。但是3-5台服务器基本能够满足器上，都可以获得不同的ID。但是步长和初始值一定需要事先需要了。使用Redis集群也可以方式单点故障的问题。

另外，比较适合使用Redis来生成每天从0开始的流水号。比如订单号=日期+当日自增长号。可以每天在Redis中生成一个Key，使用INCR进行累加。

优点：

1）不依赖于数据库，灵活方便，且性能优于数据库。

2）数字ID天然排序，对分页或者需要排序的结果很有帮助。

缺点：

1）如果系统中没有Redis，还需要引入新的组件，增加系统复杂度。

2）需要编码和配置的工作量比较大。

Twitter的snowflake算法

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。具体实现的代码可以参看https://github.com/twitter/snowflake。

snowflake算法可以根据自身项目的需要进行一定的修改。比如估算未来的数据中心个数，每个数据中心的机器数以及统一毫秒可以能的并发数来调整在算法中所需要的bit数。

优点：

1）不依赖于数据库，灵活方便，且性能优于数据库。

2）ID按照时间在单机上是递增的。

缺点：

1）在单机上是递增的，但是由于涉及到分布式环境，每台机器上的时钟不可能完全同步，也许有时候也会出现不是全局递增的情况。

利用zookeeper生成唯一ID

zookeeper主要通过其znode数据版本来生成序列号，可以生成32位和64位的数据版本号，客户端可以使用这个版本号来作为唯一的序列号。

很少会使用zookeeper来生成唯一ID。主要是由于需要依赖zookeeper，并且是多步调用API，如果在竞争较大的情况下，需要考虑使用分布式锁。因此，性能在高并发的分布式环境下，也不甚理想。

MongoDB的ObjectId

MongoDB的ObjectId和snowflake算法类似。它设计成轻量型的，不同的机器都能用全局唯一的同种方法方便地生成它。MongoDB 从一开始就设计用来作为分布式数据库，处理多个节点是一个核心要求。使其在分片环境中要容易生成得多。

其格式如下：

前4 个字节是从标准纪元开始的时间戳，单位为秒。时间戳，与随后的5 个字节组合起来，提供了秒级别的唯一性。由于时间戳在前，这意味着ObjectId 大致会按照插入的顺序排列。这对于某些方面很有用，如将其作为索引提高效率。这4 个字节也隐含了文档创建的时间。绝大多数客户端类库都会公开一个方法从ObjectId 获取这个信息。

接下来的3 字节是所在主机的唯一标识符。通常是机器主机名的散列值。这样就可以确保不同主机生成不同的ObjectId，不产生冲突。

为了确保在同一台机器上并发的多个进程产生的ObjectId 是唯一的，接下来的两字节来自产生ObjectId 的进程标识符（PID）。

前9 字节保证了同一秒钟不同机器不同进程产生的ObjectId 是唯一的。后3 字节就是一个自动增加的计数器，确保相同进程同一秒产生的ObjectId 也是不一样的。同一秒钟最多允许每个进程拥有2563（16 777 216）个不同的ObjectId。

实现的源码可以到MongoDB官方网站下载。