单例模式

最原始的单例模式：

构造函数声明为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，这就不行

懒汉与饿汉模式

• 
  
• 懒汉：之所以成为懒，是它一直在等，用到了再去用，也就是运行时才进行实例化。
  

优点：实例在被使用的时候才被创建，可以节省系统资源，体现了延迟加载的思想，不提前占坑。
缺点：线程不安全，多个线程同时调用可能会产生多个实例

• 
  
• 饿汉：饿了就不行了，要吃，主动就去觅食了，直接在类定义的时候就实例化，不等运行和调用
  

优点：写法简单，在多线程下也能保证单例实例的唯一性，不用同步，运行效率高。
缺点：在外部没有使用到该类的时候，该类的实例就创建了，若该类实例的创建比较消耗系统资源，并且外部一直没有调用该实例，那么这部分的系统资源的消耗是没有意义的。没人用就很浪费了

线程安全的懒汉模式(时间换空间)，其实就是一开始就绑定了

class singleton
{
protected:
    singleton()
    {
        pthread_mutex_init(&mutex);
    }
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;
}

恶汉模式(空间换时间)

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

总结

优点：一个类一个实例，减少了内存的开销，减少系统开销，比较专一，避免一个资源的多重利用，设置全局访问点，优化和贡献资源。

缺点：扩展行肯定极差，没有接口

使用场景：任务管理器、回收站、网站的计数（不被干扰）都是干一件事、配置资源的获取都是单例，用户从单例类得到就行了。

优点：
1. 在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例
2. 单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
3. 提供了对唯一实例的受控访问。
4. 由于在系统内存中只存在一个对象，因此可以 节约系统资源，当需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
5. 允许可变数目的实例。
6. 避免对共享资源的多重占用。

缺点：
1. 比适用于变化的对象
2. 单例类的职责太重了

场景：
1. 实例频繁创建
3. 资源共享的情况下，避免资源操作时导致的性能或损耗，利用单例进行独占。
4. 控制资源时，方便资源之间的互相通信。