用C++跟你聊聊“单例模式”，类的“计划生育”

//头文件

#ifndef Q_FIRST_DB_H
#define Q_FIRST_DB_H

#include<stdio.h>
#include<stdlib.h>
#include "sqlite3.h"
#include<string.h>


//数据库单例
class DB
{
public:
    static DB *instence();//获取数据库单例
//重点在这个函数

    void new_table();   //初始化一些基本表
    void initdb();	//往表中初始化一些数据
private:
    DB();
    ~DB();
    char *errmsg;

    static DB *My_DB;//实例
    static sqlite3 *db;//数据库文件句柄
};

#endif

//源文件
#include "q_first_db.h"

DB * DB::My_DB = NULL;
sqlite3 *DB::db = NULL;

//我只有一个数据库，所以不用传入名字了
DB::DB()    //打开数据库
{
    int rc = sqlite3_open("Guess.db",&db);
    if (rc != SQLITE_OK)
    {
        printf("%s",sqlite3_errmsg(db));
        exit(0);
    }
}

DB::~DB()
{
    sqlite3_close(db);
}

DB* DB::instence()
{
    if(!My_DB)
    {
        My_DB = new DB();
    }
    	return My_DB;
	}
}

int main()
{
    DB *table = DB::instence();	//这是在类外使用单例
    
    table->new_table();
    table->initdb();
    return 0;
}

DB* DB::instence()
{
    if(!My_DB)
    {
        My_DB = new DB();
    }
    	return My_DB;
	}
}

DB* DB::instence()
{
    if(!My_DB)	//先判定实例是否存在，如果不存在，就加锁处理
    {
    	lock(db_mutex);	//假设这个锁我已经初始化过了
    		if(!My_DB)	//这就是第二重锁定，看懂吗？
    		{
        		My_DB = new DB();
        	}
        unlock(db_mutex);	//上锁和解锁一定要同时写，就算忘记写中间步骤，也要先写解锁
    }
    	return My_DB;
	}
}

#include <iostream>
#include <process.h>
#include <windows.h>
using namespace std;
 
class Singelton{
private:
    Singelton(){
        m_count ++;
        printf("Singelton beginn");
        Sleep(1000);                            // 加sleep为了放大效果
        printf("Singelton endn");
    }
    static Singelton *single;
public:
    static Singelton *GetSingelton();
    static void print();
    static int m_count;
};
// 饿汉模式的关键：初始化即实例化
Singelton *Singelton::single = new Singelton;
int Singelton::m_count = 0;
 
Singelton *Singelton::GetSingelton(){
    // 不再需要进行实例化
    //if(single == nullptr){
    //    single = new Singelton;
    //}
    return single;
}
 
void Singelton::print(){
    cout<<m_count<<endl;
}
// 回调函数
void threadFunc(void *p){
    DWORD id = GetCurrentThreadId();        // 获得线程id
     cout<<id<<endl;
    Singelton::GetSingelton()->print();      // 构造函数并获得实例，调用静态成员函数
}
 
int main(int argc, const char * argv[]) {
    int threadNum = 3;
    HANDLE threadHdl[100];
     
    // 创建3个线程
    for(int i = 0; i<threadNum; i++){
        threadHdl[i] = (HANDLE)_beginthread(threadFunc, 0, nullptr);
    }
     
    // 让主进程等待所有的线程结束后再退出
    for(int i = 0; i<threadNum; i++){
        WaitForSingleObject(threadHdl[i], INFINITE);
    }
    cout<<"main"<<endl;                 // 验证主进程是否是最后退出
    return 0;
}