在LINUX下用C/C++写了一个连接池（访问MYSQL）的类

一、头文件【存为：connPool.h】

#ifndef __CONNECTION_POOL_H__
#define __CONNECTION_POOL_H__

#include "mutex.h"

#define  MYSQL_CONN_NUM_MAX_VALUE   500
using namespace std;

enum _USE_STATUS
{
   US_USE = 0,
   US_IDLE = 1
};

typedef  struct _sConStatus
{
   void*  connAddr;
   int    useStatus;
}sConStatus;

class CConnPool
{
public:
    CConnPool();
    ~CConnPool();
public:
    int Init(string& strMysqlIp, string&  strUser, string&  strPwd, string&  strDbName, int nMysqlPort, int nConnNum);//connection  pool init
    void* getOneConn();//get a connection
    void  retOneConn(void* pMysql);// return a connection
    void  checkConn(); // check the connection if is alive
   
    void* createOneConn();
   
public:

   char m_szMysqlIp[100];
   char m_szUser[100];
   char m_szPwd[100];
   char m_szDbName[100];
   int  m_nMysqlPort;  
   int  m_nConnNum;
     
public:
    CMutex  m_sMutex;
    vector<void*>  m_vectorConn;
    map<void*, int> m_mapVI;
    map<void*, void*> m_mapMysqlScs;
   
};

 
class CConnPoolV2
{
public:
    CConnPoolV2();
    ~CConnPoolV2();
public:
    int Init(string& strMysqlIp, string&  strUser, string&  strPwd, string&  strDbName, int nMysqlPort, int nConnNum);//connection  pool init
    void* getOneConn(); //从连接池取一个连接
    void  retOneConn(void* pConn);// 连接用完了，把它放回连接池。以便其他人用。
    void  checkConn(); // check the connection if is alive
   
    void* createOneConn();
   
private:
   string m_strMysqlIp;
   string m_strUser;
   string m_strPwd;
   string m_strDbName;
   int  m_nMysqlPort; 
   int  m_nConnNum;
     
private:
    CMutex  m_sMutex;
    vector<void*>  m_vectorConn;
    map<void*, int> m_mapVI; //  从连接的地址，快速找到索引，便于存放到m_vectorConn中。
  
};
 

#endif

 

二、源码【存为：connPool.cpp】

 

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <time.h> 
#include <iostream>                      
#include <memory>
#include <string>
#include <map>
#include <vector>

#include "mysql.h"
#include "encapsulation_mysql.h"
#include "connPool.h"
#include "mutex.h"

 

using namespace std;
using namespace EncapMysql;

CConnPool::CConnPool( )
{
}

CConnPool::~CConnPool( )
{
}

void* CConnPool::createOneConn()
{
     MYSQL*  mysql;
     mysql = mysql_init(0);
     if(mysql == NULL)
     {
    cout << "mysql_init fail**" << endl;     
    return NULL;
     }
 
     if(mysql_real_connect(mysql,  m_szMysqlIp , m_szUser ,   m_szPwd,    m_szDbName  ,  m_nMysqlPort, NULL,0)==NULL)
     {
     cout << "connect failure!" << endl;
     return NULL;
   }
     else
     {
    cout << "connect success!" << endl;
     }
     //
     return mysql;
 
}

int CConnPool::Init(string& strMysqlIp, string&  strUser, string&  strPwd, string&  strDbName, int nMysqlPort, int nConnNum)
{
 
    strcpy(m_szMysqlIp, strMysqlIp.c_str());
    strcpy( m_szUser, strUser.c_str());
    strcpy(m_szPwd, strPwd.c_str());
    strcpy(m_szDbName, strDbName.c_str());
    m_nMysqlPort = nMysqlPort;  
   m_nConnNum = nConnNum; 
  
    MYSQL*  mysql;
   
    for(int i=0; i<nConnNum; i++)
    {
       mysql = (MYSQL*)this->createOneConn();
       if(mysql == NULL)
        return -1;
       // 
      sConStatus* scs = new sConStatus();
      scs->connAddr = mysql;
      scs->useStatus = US_IDLE;
      m_vectorConn.push_back(scs); 
      m_mapVI[scs] = i;
      m_mapMysqlScs[mysql] = scs;
  }
  
  m_nConnNum = nConnNum;
}

//从连接池中取一个连接，同时，给它做一个标记，表明它已经被使用，防止别的线程再使用。
void* CConnPool::getOneConn()
{
    int N = m_vectorConn.size();
  for(int i=0; i< N; i++)
  {
      CGuard  guard(m_sMutex);
      sConStatus* scs = (sConStatus*)m_vectorConn[i];
        if(scs->useStatus ==  US_IDLE)
        {
           scs->useStatus = US_USE;
          return  scs->connAddr;
        } 
  }
  //
  return NULL;
}

//把连接归还给连接池。同时，给它做一个标记，表明它是空闲的，可以使用。
void  CConnPool::retOneConn(void* pMysql)
{
  if(!pMysql)
    return;
  // 
  map<void*, void*>::iterator  it1;
  map<void*, int>::iterator it2;
 
  CGuard  guard(m_sMutex);
 
  it1 = m_mapMysqlScs.find(pMysql);
  if(it1 == m_mapMysqlScs.end())
      return;
  it2 = m_mapVI.find(it1->second);
  if(it2 == m_mapVI.end())
      return;
  int nInx = it2->second;

  sConStatus* scs = (sConStatus*) m_vectorConn[nInx];
  scs->useStatus = US_IDLE;
  
}

void  CConnPool::checkConn()
{
   map<void*, void*>::iterator  it1;
   MYSQL*  mysql;
   // 
    for(int i=0; i<m_nConnNum ; i++)
    {
     CGuard  guard(m_sMutex);
     sConStatus* scs = (sConStatus*)m_vectorConn[i];
     if(scs->useStatus == US_USE)
         continue;
     //   
     mysql =(MYSQL*)(scs->connAddr);
     int status=mysql_query(mysql, "select count(*) from t_user;" );
    if(status != 0) //说明连接已经不可用了。
    {
        it1 = m_mapMysqlScs.find(mysql);
      if(it1 != m_mapMysqlScs.end())
       {
          m_mapMysqlScs.erase(it1);
       }
      //
        mysql_close(mysql);
        //
        mysql = (MYSQL*)this->createOneConn();
      m_mapMysqlScs[mysql] = scs;
    }
    }
    //
}

 
////////////////////////////// 2011-01-20, 这个类这样写，感觉耦合性更为松散，比较好。使用起来也好理解一些。
CConnPoolV2::CConnPoolV2( )
{
}

CConnPoolV2::~CConnPoolV2( )
{
}

//创建一个连接，并设为 IDLE状态。
void* CConnPoolV2::createOneConn()
{
   try
   {
     CEncapMysql*  pEM = new CEncapMysql();
     if(pEM == NULL)
     {
      printf("pEM == NULL**\r\n"); 
      return NULL;
     }   
     //
     int nRet = pEM->Connect(m_strMysqlIp.c_str(), m_strUser.c_str(), m_strPwd.c_str());
     if(nRet != 0)
     {
      printf("pEM->Connect fail**\r\n"); 
      return NULL;
     }         
        //      
      pEM->SetIdle();
     //
     return pEM;
  }  
  catch(...)
  {
     printf("createOneConn  exception**\r\n"); 
     return NULL;
  }
}

//成功： 返回0
int CConnPoolV2::Init(string& strMysqlIp, string&  strUser, string&  strPwd, string&  strDbName, int nMysqlPort, int nConnNum)
{
 
    m_strMysqlIp  = strMysqlIp;
    m_strUser     = strUser;
    m_strPwd      = strPwd;
    m_strDbName   = strDbName;
    m_nMysqlPort = nMysqlPort;  
   m_nConnNum = nConnNum; 
  
    CEncapMysql* pEM;
    int nRet;
    for(int i=0; i<nConnNum; i++)
    {
       pEM = (CEncapMysql*)this->createOneConn();
        if(!pEM )
          return -1;
       // 
      m_vectorConn.push_back(pEM); 
      m_mapVI[pEM] = i;
  }
  
  return  0;
}

void* CConnPoolV2::getOneConn()
{
    CGuard  guard(m_sMutex);
    //
  for(int i=0; i< m_nConnNum; i++)
  {

      CEncapMysql* pEM = (CEncapMysql*)m_vectorConn[i];
        if( pEM->IsIdle())
        {
           pEM->SetUsed();
          return pEM;
        } 
  }
  //可能访问MYSQL的用户较多，连接池中已无空闲连接了。只要总连接数没有超限，就新建一个连接。
  if(m_nConnNum < MYSQL_CONN_NUM_MAX_VALUE)
  {
     CEncapMysql* pEM = (CEncapMysql*)this->createOneConn();
        if(!pEM )
          return NULL;
       // 
      m_vectorConn.push_back(pEM); 
      m_mapVI[pEM] = m_nConnNum++;
  } 
  //
  return NULL;
}

void  CConnPoolV2::retOneConn(void* pConn)
{
  map<void*, int>::iterator it;
 
  CGuard  guard(m_sMutex);

  it = m_mapVI.find(pConn);
  if(it == m_mapVI.end())
  {
      printf("retOneConn  fail***\n"); 
      return;
  }   
  int nInx = it->second;

  CEncapMysql* pEM = (CEncapMysql*) m_vectorConn[nInx];
  pEM->SetIdle();

   printf("retOneConn  succ!\n"); 
}

void  CConnPoolV2::checkConn()
{
   
    //暂时可以不实现。因为查询失败时，已重新连接了。
}