单例模式——饿汉式和懒汉式

单例模式：一个类只允许存在唯一的对象，并提供它的访问方式

创建思路：

　　1.禁止在类的外部创建对象：私有化构造函数

　　2.在类的内部提供唯一的对象：静态成员变量

　　3.提供访问唯一对象的方法：静态成员函数

创建方式：

　　1.饿汉式：无论用或不用，陈晓旭启动即创建

　　2.懒汉式：用的时候创建，不用的时候销毁

//单例模式 饿汉式
//无论用不用，程序启动即创建
#include <iostream>
using std::cout;
using std::endl;

class Singleton{
public:
    static Singleton& getInstance(){
        return s_instance;
    }
    int getData(){
        return m_data;
    }

private:
    Singleton(int data=0):m_data(data){}
    Singleton(const Singleton& that);

    static Singleton s_instance;
    int m_data;
};
Singleton Singleton::s_instance(666);

int main(){
    Singleton& s = Singleton::getInstance();
    cout << s.getData()<< endl;

    return 0;
}

//单例对象：懒汉式
//用时创建，不用就销毁，需要手动调用销毁
//如果是多个使用者，单例对象的析构函数应该是最后一个使用者调用，故加入计数
#include <iostream>
using namespace std;

class Singleton{
public:
    static Singleton& getInstance(){
        if(p_instance == NULL){
            p_instance = new Singleton(12345);
        }
        s_count++;
        return *p_instance;
    }
    //单例对象不用即销毁
    //单例对象可能有多个使用者，应该时最后一个使用者调用release才去delete
    void release(){
        if(--s_count == 0 && p_instance != NULL){
            delete p_instance;
            p_instance = NULL;
        }
    }
    void print(){
        cout << m_data << endl;
    }
private:
    Singleton(int data=0):m_data(data){cout << "单例对象被创建了" << endl;}
    Singleton(const Singleton& that);
    ~Singleton(){cout << "单例对象被销毁了" << endl;}

    int m_data;
    static Singleton* p_instance;
    static int s_count;//计数：记录单例使用者的个数
};
Singleton* Singleton::p_instance = NULL;
int Singleton::s_count = 0;

int main(){
    cout << "main" << endl;
    Singleton& s1 = Singleton::getInstance();
    cout << &s1 << endl;
    s1.print();
    Singleton& s2 = Singleton::getInstance();
    cout << &s2 << endl;
    s2.print();
    Singleton& s3 = Singleton::getInstance();
    cout << &s3 << endl;
    s3.print();
    s3.release();
    s2.release();
    s1.release();

    return 0;
}

//单例模式：懒汉式
//将上面的代码用classA将其封装
//利用A的构造函数和析构函数，自动创建和释放
//完成了多线程的安全单例模式
#include <iostream>
#include <pthread.h>
#include <cstdio>
using std::cout;
using std::endl;

//静态初始化锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

class Singleton{
public:
    static Singleton& getInstance(){
        pthread_mutex_lock(&mutex);  //加锁
        if(p_instance == NULL){
            p_instance = new Singleton(666);
        }
        m_count++;
        pthread_mutex_unlock(&mutex);  //解锁
        return *p_instance;
    }

    void destroy(){
        cout << "destroy" << endl;
        pthread_mutex_lock(&mutex); //加锁
        if(--m_count == 0 && p_instance != NULL){
            delete p_instance;
            p_instance = NULL;
        }
        pthread_mutex_unlock(&mutex);  //解锁
    }
    int getData(){
        return m_data;
    }
private:
    Singleton(int data=0):m_data(data){cout << "Singleton" << endl;}
    Singleton(const Singleton& that);
    ~Singleton(){cout << "~Singleton" << endl;}

    static Singleton* p_instance;
    int m_data;
    static int m_count;
};

Singleton* Singleton::p_instance = NULL;
int Singleton::m_count = 0;

class A{
public:
    A():s(Singleton::getInstance()){}
    ~A(){s.destroy();}
    int get(){
        return s.getData();
    }
private:
    Singleton& s;
};

void* funa(void* arg){
    A a;
    cout << "funa" << endl;
}

void* funb(void* arg){
    A a;
    cout << "funb" << endl;
}

int main(){
    pthread_t pa, pb;//创建2个线程
    pthread_create(&pa,NULL,funa,NULL);
    pthread_create(&pb,NULL,funb,NULL);
    
    pthread_detach(pa);
    pthread_detach(pb);

    getchar();
    //等待，销毁线程
    //pthread_join(pa,NULL);
    //pthread_join(pb,NULL);
    
    //销毁mutex锁
    pthread_mutex_destroy(&mutex);
    return 0;
}