【服务器编程】多线程安全数据库连接池

某风平浪静的晚上，我和多线程搅上劲，如何在多线程环境安全创建连接池、释放、使用，想了很久，写了很久，写出了如下代码，感觉也很多bug吧。

发表此文，谨表示我今晚不知道为什么如此 较真，很想做到完美，可是能力还是不到那个高度，写不出很完美的代码。

如果有想法的同志路过，留点提示给我，谢谢谢谢。

/* 析构不知道怎么在多线程保证安全，程序员责任，我的脑袋要炸了 */
/* 销毁由一个线程完成，而创建和使用是线程安全的连接池 */
class MYSQLConnPool
{
public:
	typedef enum {
		E_MALLOC, 	/* 分配线程池时失败 */
		E_SUM_TO_MAX,	/* 连接池的连接数过大 */
		E_EXIST,		/* 连接池已存在 */
		E_NO_SOURCE,	/* 没有空闲连接 */
		E_INIT_SEM,	/* 初始化信号量错误（也许不该这样） */
		NONERR
	}ERRNO;
public:
	/* Singleton模式*/
	static MYSQLConnPool* CreateConnPool(const char *host, const char *user, const char *psw, const char *db, int conn_num)
	{
		
		pthread_mutex_lock(&m_MutexCreat);

		/* 连接数太大 */
		if (conn_num > MAX_CONN_NUM)
		{
			pthread_mutex_lock(&m_MutexMap);
			m_ErrMap[pthread_self()] = E_SUM_TO_MAX;
			pthread_mutex_unlock(&m_MutexMap);
			pthread_mutex_unlock(&m_MutexCreat);
			return nullptr;
		}
		if (m_ConnPool == nullptr)
		{
			m_ConnPool = new MYSQLConnPool(host, user, psw, db, conn_num);
			if (m_ErrMap[pthread_self()] == E_INIT_SEM)
			{/* 初始化信号量时出错 */
				delete m_ConnPool;
				pthread_mutex_unlock(&m_MutexCreat);
				return nullptr;
			}
			if (m_ConnPool)
			{/* 建立连接池成功 */
				pthread_mutex_unlock(&m_MutexCreat);
				return m_ConnPool;
			}
			/* new失败 */
			pthread_mutex_lock(&m_MutexMap);
			m_ErrMap[pthread_self()] = E_MALLOC;
			pthread_mutex_unlock(&m_MutexMap);
			pthread_mutex_unlock(&m_MutexCreat);
			return nullptr;
		}
		/* 该进程已经生成连接池 */
		pthread_mutex_lock(&m_MutexMap);
		m_ErrMap[pthread_self()] = E_EXIST;
		pthread_mutex_unlock(&m_MutexMap);
		pthread_mutex_unlock(&m_MutexCreat);
		return nullptr;

	}

	/*
	*	试想：一个监听主线程有几个服务线程，而每个服务线程（不同的服务封装了一个类）都想用到这个连接池（一个进程一个连接池），
	*	如果又上层（主线程）传到参数（连接池）到下层（服务线程）方式，那么太破坏服务类的封装了，故定义一个返回池指针的函数。
	*	（针对本开发的项目）
	*/
	static MYSQLConnPool* GetConnPoolPointer()
	{
		return m_ConnPool;
	}

	static ERRNO GetLastError()
	{
		pthread_mutex_lock(&m_MutexMap);
		std::map<pthread_t, ERRNO>::iterator ite;
		ite = map.find(pthread_self());
		if (ite == map.end())
		{
			pthread_mutex_unlock(&m_MutexMap);
			return NONERR;
		}
		ERRNO e = m_ErrMap[pthread_self()];
		pthread_mutex_unlock(&m_MutexMap);
		return e;
	}

	MYSQL *GetConnection()
	{/* 连接池没有空闲连接就阻塞 */	
		sem_wait(&m_ConnNum);
		pthread_mutex_lock(&m_MutexConnVec);
		MYSQL *conn = m_ConnVec.back();
		m_ConnVec.pop_back();
		pthread_mutex_unlock(&m_MutexConnVec);
		return conn;
	}

	void RecoverConnection(MYSQL *conn)
	{
		if (conn)
		{
			pthread_mutex_lock(&m_MutexConnVec);
			m_ConnVec.push_back(conn);
			pthread_mutex_unlock(&m_MutexConnVec);
			sem_post(&m_ConnNum);
		}
	}

	/* 目前没想到如何做到在多线程环境析构而绝对不冲突 */
	/* 虚函数不是原子操作，在多线程环境有可能在析构同时，另外一个线程在使用连接池 */
	~MYSQLConnPool()
	{
		/* 回收所有资源（连接）后，销毁信号量，就不可能再有线程非法操作了 */
		for (int i = 0; i < m_count; ++i)
		{/* 所以，使用了一定要归还啊，不然死的很惨+_+ */
			sem_wait(&m_ConnNum);
		}
		sem_destroy(&m_ConnNum);
		pthread_mutex_destroy(&m_MutexConnVec);
		for (int i = 0; i < m_ConnNum; ++i)
		{
			mysql_close(m_ConnVec[i]);
		}
		m_ConnPool = nullptr;
	}

private:
	MYSQLConnPool(const char *host, const char *user, const char *psw, const char *db, int conn_num);

private:
	/* 根据线程存储了已发生什么错误 */
	pthread_mutex_t m_MutexMap;
	std::map<pthread_t, ERRNO> m_ErrMap;

	/* 连接池最大连接数 */
	static const int MAX_CONN_NUM = 16;

	/* 连接池的连接数 */
	int m_count;
	/* 可用资源的信号量表示 */
	sem_t m_ConnNum;
	pthread_mutex_t m_MutexConnVec;

	/* 连接列表 */
	std::vector<MYSQL*> m_ConnVec;

	/* 多个线程一起创建时，使用互斥防止创建多个 */
	static pthread_mutex_t m_MutexCreat;

	/* 实例指针*/
	static MYSQLConnPool *m_ConnPool;
};

MYSQLConnPool* MYSQLConnPool::m_ConnPool = nullptr;

pthread_mutex_t MYSQLConnPool::m_MutexCreat = PTHREAD_MUTEX_INITIALIZER;


MYSQLConnPool::MYSQLConnPool(const char *host, const char *user, const char *psw, const char *db, int conn_num)
{
	m_count = 0;
	for (int i = 0; i < conn_num; ++i)
	{
		MYSQL *conn = mysql_init(nullptr);
		if (!conn)
			continue;
		conn = mysql_real_connect(conn, host, user, psw, db, 0, nullptr, 0);
		if (!conn)
			continue;
		m_count++;
		m_ConnVec.push_back(conn);
	}
	m_ErrMap[pthread_self()] = NONERR;
	int ret = sem_init(&m_ConnNum, 0, m_ConnVec.size());
	if (ret == -1)
	{
		pthread_mutex_lock(&m_MutexMap);
		m_ErrMap[pthread_self()] = E_INIT_SEM;
		pthread_mutex_unlock(&m_MutexMap);
	}
	m_MutexConnVec = PTHREAD_MUTEX_INITIALIZER;
}