自己写的一个基于ocilib的c连接池，未经测试

#include "ocilib.h"
#include "pthread.h"

#define DBFAIL -1

#define NOWAIT 1
#define WAITING	0

#define USE 0
#define NOUSE 1

typedef struct(
OCI_Connection *cn;
int	status;    //0-未用 1-使用中

TP_DBCONN_NODE *next;
)TP_DBCONN_NODE;

TP_DBCONN_NODE *g_header = NULL;
int g_cur_conn_num = 0;
int g_now_use_conn = 0;
int g_min_conn;
int g_max_conn;
int g_incr_conn;
char g_user[128] = {0};
char g_passwd[128]= {0};
char g_tns[128]= {0};
pthread_mutex_t conn_mutx;
pthread_t pool_thread;

int g_adjust_count = 0; //减少连接数的计数
int g_adjust_pecent = 80; //进行调度的比率
int g_adjust_threshold = 10; //进行调度的阈值

void oci_err_handler(OCI_Error *err)
{
printf(
"code  : ORA-%05i\n"
"msg   : %s\n"
"sql   : %s\n",
OCI_ErrorGetOCICode(err),
OCI_ErrorGetString(err),
OCI_GetSql(OCI_ErrorGetStatement(err))
);
}

int oci_db_pool_init(char *user, char *passwd, char *tns, int min_conn, int max_conn, int incr_conn)
{

TP_DBCONN_NODE *tmp_node = NULL;
TP_DBCONN_NODE *pre_tmp_node = NULL;
pthread_attr_t attr;
int i;

g_min_conn = min_conn;
g_max_conn = max_conn;
g_incr_conn = incr_conn;

strncpy(g_user, user, sizeof(g_user) - 1);
strncpy(g_passwd, passwd, sizeof(g_passwd) - 1);
strncpy(g_tns, tns, sizeof(g_tns) - 1);
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 512000);//500K

//初始化OCI
if (!OCI_Initialize(oci_err_handler, NULL, OCI_ENV_DEFAULT|OCI_ENV_THREADED|OCI_ENV_CONTEXT))
return DBFAIL;

//初始化数据库连接
for (i = 0; i < min_conn; i++)
{
pre_tmp_node = tmp_node;
tmp_node = malloc(sizeof(TP_DBCONN_NODE));
memset((void *)tmp_node, 0, sizeof(TP_DBCONN_NODE));

tmp_node->cn = OCI_ConnectionCreate(tns, user, passwd, OCI_SESSION_DEFAULT);
if (tmp_node->cn == NULL)
{
free(tmp_node);
oci_db_pool_free();
return DBFAIL;
}

if (i == 0)//头节点
g_header = tmp_node;
else//非头节点
pre_tmp_node->next = tmp_node;
//TODO

cur_conn_num++;
}
if (pthread_mutex_init(&conn_mutx, NULL) != 0)
{
oci_db_pool_free();
return DBFAIL;
}
//创建连接池守护线程
if (pthread_create(&pool_thread, &attr, (void *)db_pool_run, NULL) != 0)
printf("pthread_create error\n");
}

int oci_db_pool_free()
{
TP_DBCONN_NODE *tmp_node = g_header;
TP_DBCONN_NODE *pre_tmp_node = NULL;

while (tmp_node != NULL)
{
pre_tmp_node = tmp_node;
tmp_node = tmp_node->next;

//断开数据库连接
OCI_ConnectionFree(pre_tmp_node->cn);

//释放内存
free(pre_tmp_node);
}
cur_conn_num = 0;
g_header = NULL;
OCI_Cleanup();
pthread_mutex_destory(&conn_mutx);
}
//增加一个数据库连接
OCI_Connection *oci_db_add_conn(int type)
{
TP_DBCONN_NODE *tmp_node = NULL;
TP_DBCONN_NODE *pre_tmp_node = NULL;

//加锁
if (pthread_mutex_lock(&conn_mutx) != 0)
{
return NULL;
}
//寻找最后一个节点
tmp_node = g_header;

while (tmp_node->next != NULL)
{
tmp_node = tmp_node->next;
if (tmp_node == NULL)
break;
}
if (tmp_node != NULL)
{
pre_tmp_node = tmp_node;
tmp_node = malloc(sizeof(TP_DBCONN_NODE));
memset((void *)tmp_node, 0, sizeof(TP_DBCONN_NODE));

tmp_node->cn = OCI_ConnectionCreate(g_tns, g_user, g_passwd, OCI_SESSION_DEFAULT);
if (tmp_node->cn == NULL)
{
free(tmp_node);
tmp_node = NULL;
}else
{
if (g_header == NULL)//头节点
g_header = tmp_node;
else//非头节点
pre_tmp_node->next = tmp_node;
tmp_node->status = type;
g_cur_conn_num++;
}
}else
tmp_node = NULL;
//释放锁
if (pthread_mutex_unlock(&conn_mutx) != 0)
{
return NULL;
}
return tmp_node;
}
//减少一个数据库连接
int oci_db_del_conn()
{
TP_DBCONN_NODE *tmp_node = NULL;
TP_DBCONN_NODE *pre_tmp_node = NULL;
int ret;
//加锁
if (pthread_mutex_lock(&conn_mutx) != 0)
{
return NULL;
}
tmp_node = g_header;
//释放连接
while (tmp_node->stauts != 0)
{
pre_tmp_node = tmp_node;
tmp_node = tmp_node->next;
if (tmp_node == NULL)
break;
}
if (tmp_node != NULL)
{
//断开数据库连接
OCI_ConnectionFree(tmp_node->cn);
if (tmp_node == g_header)
{
g_header = g_header->next;
free(tmp_node);
}else
{
pre_tmp_node->next = tmp_node->next;
free(tmp_node);
}
g_cur_conn_num--;
ret = 0;

}else
ret = -1;
//释放锁
if (pthread_mutex_unlock(&conn_mutx) != 0)
{
return NULL;
}
return ret;
}
/*
0-WAITING
1-NOWAIT
*/
OCI_Connection *oci_db_get_conn(int type)
{
TP_DBCONN_NODE *tmp_node = NULL;
OCI_Connection *cn = NULL;
//获取锁
if (type == NOWAIT)
{
if (pthread_mutex_trylock(&conn_mutx) != 0)
return NULL;
}else
{
if (pthread_mutex_lock(&conn_mutx) != 0)
return NULL;
}
tmp_node = g_header;

//查找现有列表获取连接
while (tmp_node->status != 0)
{
tmp_node = tmp_node->next;
if (tmp_node == NULL)
break;
}
//在现有连接中找到
if (tmp_node != NULL)
{
cn = tmp_node->cn;
tmp_node->status = 1;
if ((oci_db_test_conn(tmp_node->cn) != TRUE) //查询失败?
{
OCI_ConnectionFree(tmp_node->cn);
tmp_node->cn = OCI_ConnectionCreate(g_tns, g_user, g_passwd, OCI_SESSION_DEFAULT);
if (tmp_node->cn == NULL)
{
tmp_node->status = 2;
}
}
g_now_use_conn++;
}else //未找到 已满?
{
//新增数据库连接
if (g_cur_conn_num < g_max_conn)
{
cn = oci_db_add_conn(USE);
}
}

//释放锁
if (pthread_mutex_unlock(&conn_mutx) != 0)
{
return NULL;
}
return cn;
}

//释放一个连接
int oci_db_free_conn(OCI_Connection *cn)
{
TP_DBCONN_NODE *tmp_node = NULL;

//加锁
if (pthread_mutex_lock(&conn_mutx) != 0)
{
return NULL;
}
tmp_node = g_header;
//释放连接
while (cn != tmp_node->cn)
{
tmp_node = tmp_node->next;
if (tmp_node == NULL)
break;
}
tmp_node->status = 0;
g_now_use_conn--;
//释放锁
if (pthread_mutex_unlock(&conn_mutx) != 0)
{
return NULL;
}

}
//检测连接
int oci_db_test_conn(OCI_Connection *cn)
{
OCI_Statement *st;
int ret;
st = OCI_StatementCreate(cn);
ret = OCI_ExecuteStmt(st, "select 1 from dual;");
OCI_StatementFree(st);
return ret;
}

//检测活跃状态
int oci_db_active_test()
{
TP_DBCONN_NODE *tmp_node = NULL;

while (tmp_node != NULL)
{
if (tmp_node->status != 1)
{
if ((oci_db_test_conn(tmp_node->cn) != TRUE) //查询失败?
{
OCI_ConnectionFree(tmp_node->cn);
tmp_node->cn = OCI_ConnectionCreate(g_tns, g_user, g_passwd, OCI_SESSION_DEFAULT);
if (tmp_node->cn == NULL)
{
tmp_node->status = 2;
}
}
}
tmp_node = tmp_node->next;
}

}

static void db_pool_run(void * args)
{
while(1)
{
sleep(10);
oci_db_active_test();
if ((g_now_use_conn *100 / g_cur_conn_num) < g_adjust_pecent)
g_adjust_count++;
else
g_adjust_count = 0;

if (g_adjust_count > g_adjust_threshold)
{
oci_db_del_conn();
g_adjust_count = 0;
}
}
}