遇到oracle错误24909,使用Pro C++实现数据库连接池采用多线程方式访问oracle数据库 | 学步园...

weixin_39615643

于 2021-04-13 15:58:54 发布

阅读量1.1k

点赞数

文章标签：遇到oracle错误24909

数据库连接作为一种资源，我们的应用必须对之进行行之有效的管理。我们在访问数据库的时候，一般传统上采用先建立连接，然后使用该连接访问数据库，在使用完毕后，关闭该连接。这是我们经常采用的方法。该方法的好处是使用简单，不用对连接进行任何管理。但随之带来的缺点也就出现了，在应用需要频繁访问数据库的时候，这种方法就会使程序的效率十分低下，甚至有时候是不能满足应用的需要的。随着数据库连接池技术出现了，我们的应用根据访问数据库的频率动态决定创建连接的数量，以及决定在适当的时刻可以关闭一些数据库连接，用以节省这种资源。笔者最近在参考了网上大量代码的同时，实现了如何利用Pro C++使用数据库连接池完成了多线程对oracle数据库的访问。本着来源于网络，共享与网络的精神，和大家共同探讨，其中笔者的大部分代码来源是黄剑锋先生的共享代码，在此深表感谢。实现的基本功能如下：

1：可以设定最小的数据库连接数。

2：可以设定最大的数据库连接数。

3：当数据库某个连接空闲时间多长时间后，该连接池会自动断开连接以节省数据库连接资源。

4：提供了每个连接被使用的次数接口，方便统计和分析各个连接的情况。

5：提供了每个连接从上次访问完毕，懂查看的时候为止，已经空闲的时长，以秒为单位。

6：可以动态访问数据库存储过程，即存储过程的名字可以动态变化的。

CConnection：

#pragma once

#include

#define RT_OK 0

#define RT_NG -1

#define DB_CORE 0

#define DB_CORE_1 DB_CORE

using namespace std;

/*数据库错误原因*/

#defineRT_CONNECT_FAILED-2

#defineRT_SOURCE_BUSY -3

#defineRT_NO_DATA_FOUND -4 /*when fetch cursor over or cursor is empty*/

#defineRT_DOUBLE_KEY -5 /*unique constraint violated*/

#defineRT_OTHER_ERROR -99

/****************************************数据库单连接******************************************/

class CConnection

{

public:

CConnection();

CConnection(std::string db_string, std::string db_name);

virtual ~CConnection();

void settimerid(int timerid);

int gettimerid();

void addinvoke();

void set(std::string db_string, std::string db_name);

void set_db_string(std::string db_string);

void set_db_name(std::string db_name);

string get_db_string();

string get_db_name();

void output();

void setidletimepoint();

void* getctctx();

static int multi_thread();

int start();

int stop();

int connect();

int disconnect();

int reconnect();

bool is_connected();

/*示例*/

int DML_DEMO_1();

int DML_DEMO_2(int i);

int DML_DEMO_3(int i);

int DML_DEMO_4(char* inputparam, char* outputparam);

int DML_DEMO_5(char* spname, char* inputparam, char* outputparam);

private:

bool db_connected_;

int invoke_;

time_t idletimepoint_;

int timerid_;

/*数据库连接上下文*/

void * ctx_;

std::string db_string_; /*数据库连接串 user/pwd@sid*/

std::string db_name_; /*数据库连接别名*/

int SqlError(void *_sqlca, const char *_FunName);

};

/*==================================================================================================

* 项目名称: Proc++程序模板

* 功能: 实现Proc预编译程序设计模式

* 作者: huangjf

* 联系: huangjf@ffcs.cn

* 最近修改: 2010-7-15

* 版本: v2.0.1

==================================================================================================*/

#include

#include "Logger.h"

#include "Connection.h"

CConnection::CConnection()

{

CLogger::createinstance()->logdebugmsg("(+)connection address=%08x\n", this);

db_connected_ = false;

ctx_ = NULL;

db_string_ = "NULL";

db_name_ = "NULL";

invoke_ = 0;

idletimepoint_ = time(NULL);

timerid_ = -1;

}

CConnection::CConnection(std::string db_string, std::string db_name)

{

CLogger::createinstance()->logdebugmsg("(+)connection address=%08x\n", this);

db_connected_ = false;

ctx_ = NULL;

db_string_ = db_string;

db_name_ = db_name;

invoke_ = 0;

idletimepoint_ = time(NULL);

timerid_ = -1;

}

CConnection::~CConnection()

{

CLogger::createinstance()->logdebugmsg("(-)connection address=%08x\n", this);

db_connected_ = false;

}

void CConnection::settimerid(int timerid)

{

timerid_ = timerid;

}

int CConnection::gettimerid()

{

return timerid_;

}

void CConnection::addinvoke()

{

invoke_++;

}

void CConnection::set(std::string db_string, std::string db_name)

{

db_string_ = db_string;

db_name_ = db_name;

}

void CConnection::set_db_string(std::string db_string)

{

db_string_ = db_string;

}

void CConnection::set_db_name(std::string db_name)

{

db_name_ = db_name;

}

string CConnection::get_db_string()

{

return db_string_;

}

void CConnection::setidletimepoint()

{

time(&idletimepoint_);

}

void CConnection::output()

{

CLogger::createinstance()->logdebugmsg("connection=%08x invoke=%d idletime=%d\n", this, invoke_, time(NULL) - idletimepoint_);

}

void* CConnection::getctctx()

{

return ctx_;

}

string CConnection::get_db_name()

{

return db_name_;

}

int CConnection::multi_thread()

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

EXEC SQL ENABLE THREADS;

CLogger::createinstance()->logdebugmsg("start database muti thread mode：success\n");

return RT_OK;

sqlerr:

CLogger::createinstance()->logdebugmsg("start database muti thread mode：failure\n");

return RT_NG;

}

int CConnection::start()

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

EXEC SQL BEGIN DECLARE SECTION;

sql_context ctx = NULL;

EXEC SQL END DECLARE SECTION;

EXEC SQL CONTEXT ALLOCATE :ctx;

this->ctx_ = ctx;

if (this->ctx_ != NULL)

{

CLogger::createinstance()->logdebugmsg("create database context：success\n");

return RT_OK;

}

else

{

CLogger::createinstance()->logdebugmsg("create database context：failure\n");

return RT_NG;

}

sqlerr:

return (SqlError(&sqlca, "start()"));

}

int CConnection::stop()

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

EXEC SQL BEGIN DECLARE SECTION;

sql_context ctx = NULL;

EXEC SQL END DECLARE SECTION;

ctx = this->ctx_;

EXEC SQL CONTEXT FREE :ctx;

CLogger::createinstance()->logdebugmsg("destroy database context：success\n");

return RT_OK;

sqlerr:

CLogger::createinstance()->logdebugmsg("destroy database context：failure\n");

return (SqlError(&sqlca, "stop()"));

}

int CConnection::connect()

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

if (this->ctx_ == NULL) return RT_NG;

if (this->db_connected_ == true) return RT_OK;

EXEC SQL BEGIN DECLARE SECTION;

VARCHAR vcConnStr[512]; /*数据库连接串 user/pwd@sid*/

VARCHAR vcLinkName[64]; /*数据库连接别名*/

sql_context ctx = NULL; /*数据库连接上下文*/

EXEC SQL END DECLARE SECTION;

ACE_OS::memset(&vcConnStr, 0x00, sizeof(vcConnStr));

ACE_OS::memset(&vcLinkName, 0x00, sizeof(vcLinkName));

ACE_OS::strncpy((char *)vcConnStr.arr, this->db_string_.c_str(), this->db_string_.length());

vcConnStr.len = ACE_OS::strlen((char *)vcConnStr.arr);

ACE_OS::strncpy((char *)vcLinkName.arr, this->db_name_.c_str(), this->db_name_.length());

vcLinkName.len = ACE_OS::strlen((char *)vcLinkName.arr);

ctx = this->ctx_;

EXEC SQL CONTEXT USE :ctx;

EXEC SQL CONNECT :vcConnStr AT :vcLinkName;

this->db_connected_ = true;

CLogger::createinstance()->logdebugmsg("connect to database [%s]：success\n", this->db_name_.c_str());

return RT_OK;

sqlerr:

this->db_connected_ = false;

CLogger::createinstance()->logdebugmsg("connect to database [%s]：failure\n", this->db_name_.c_str());

return (SqlError(&sqlca, "connect()"));

}

int CConnection::disconnect()

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

if (this->ctx_ == NULL) return RT_NG;

if (this->db_connected_ == false) return RT_OK;

EXEC SQL BEGIN DECLARE SECTION;

VARCHAR vcLinkName[64]; /*数据库连接别名*/

sql_context ctx = NULL; /*数据库连接上下文*/

EXEC SQL END DECLARE SECTION;

ACE_OS::memset(&vcLinkName, 0x00, sizeof(vcLinkName));

ACE_OS::strncpy((char *)vcLinkName.arr, this->db_name_.c_str(), this->db_name_.length());

vcLinkName.len = ACE_OS::strlen((char *)vcLinkName.arr);

ctx = this->ctx_;

EXEC SQL CONTEXT USE :ctx;

/*EXEC SQL AT :vcLinkName ROLLBACK WORK RELEASE;*/

EXEC SQL AT :vcLinkName COMMIT WORK RELEASE;

this->db_connected_ = false;

CLogger::createinstance()->logdebugmsg("disconnect to database [%s]：success\n", this->db_name_.c_str());

return RT_OK;

sqlerr:

this->db_connected_ = false;

CLogger::createinstance()->logdebugmsg("disconnect to database [%s]：failure\n", this->db_name_.c_str());

return (SqlError(&sqlca, "disconnect()"));

}

int CConnection::reconnect()

{

this->disconnect();

this->connect();

return this->db_connected_==true ? RT_OK : RT_NG;

}

bool CConnection::is_connected()

{

return this->db_connected_;

}

int CConnection::SqlError(void *_sqlca, const char *_FunName)

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

if (this->ctx_ == NULL) return RT_NG;

if (this->db_connected_ == false) return RT_NG;

intiRet;

EXEC SQL BEGIN DECLARE SECTION;

VARCHAR vcLinkName[64]; /*数据库连接别名*/

sql_context ctx = NULL; /*数据库连接上下文*/

struct sqlca *sql_ca;

EXEC SQL END DECLARE SECTION;

memset(&vcLinkName, 0x00, sizeof(vcLinkName));

ACE_OS::strncpy((char *)vcLinkName.arr, this->db_name_.c_str(), this->db_name_.length());

vcLinkName.len = ACE_OS::strlen((char *)vcLinkName.arr);

ctx = this->ctx_;

EXEC SQL CONTEXT USE :ctx;

sql_ca = (struct sqlca *)_sqlca;

if (sql_ca->sqlcode == 0)

{

returnRT_OK;

}

if (sql_ca->sqlcode == -1)

{

iRet = RT_DOUBLE_KEY;

}

else if (((sql_ca->sqlcode == -1012)||(sql_ca->sqlcode == -1041)||(sql_ca->sqlcode == -3114)||(sql_ca->sqlcode == -1003)||(sql_ca->sqlcode == 1455))||((sql_ca->sqlcode <= -12150)&&(sql_ca->sqlcode >= -12285))||((sql_ca->sqlcode >= -12699)&&(sql_ca->sqlcode <= -12500)))

{

iRet = RT_CONNECT_FAILED;

this->db_connected_ = false;

}

else if (sql_ca->sqlcode == 1403 ) /*no data found*/

{

iRet = RT_NO_DATA_FOUND;

}

else if (sql_ca->sqlcode == -54)

{

iRet = RT_SOURCE_BUSY;

}

else if (sql_ca->sqlcode == -1)

{

iRet = RT_DOUBLE_KEY; /*unique constraint violated*/

}

else

{

iRet = RT_OTHER_ERROR;

}

CLogger::createinstance()->logdebugmsg("database [%s] happen error：\nfunction ：[%s]\nresult ：[%d]\nerrorcode：[%d]\nerrorinfo：[%s]\n",

this->db_name_.c_str(),

_FunName,

iRet,

sql_ca->sqlcode,

sql_ca->sqlerrm.sqlerrmc);

/*ORA-01033: ORACLE initialization or shutdown in progress*/

/*ORA-24324: service handle not initialized*/

/*ORA-03114: not connected to ORACLE*/

/*ORA-01089: immediate shutdown in progress - no operations are permitte */

/*ORA-24909: call in progress. Current operation cancelled*/

/*ORA-01012: not logged on*/

/*ORA-01438: value larger than specified precision allows for this colum*/

/*ORA-00001: 违反唯一约束条件*/

/*ORA-01400: 无法将 NULL 插入*/

EXEC SQL AT :vcLinkName ROLLBACK WORK;

sqlerr:

return iRet;

}

/********************************************************代码演示区**********************************************************/

/*********************************************************************************************

*功能：SELECT示例

*输入：NONE

*输出：NONE

*返回：RT_OK：成功，RT_NG：失败

*修改记录：NONE

*********************************************************************************************/

int CConnection::DML_DEMO_1()

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

if (this->ctx_ == NULL) return RT_NG;

if (this->db_connected_ == false) return RT_NG;

EXEC SQL BEGIN DECLARE SECTION;

VARCHAR vcLinkName[64]; /*数据库连接别名*/

sql_context ctx = NULL; /*数据库连接上下文*/

VARCHAR v_sysdate[32];

EXEC SQL END DECLARE SECTION;

ACE_OS::memset(&vcLinkName, 0x00, sizeof(vcLinkName));

ACE_OS::strncpy((char *)vcLinkName.arr, this->db_name_.c_str(), this->db_name_.length());

vcLinkName.len = ACE_OS::strlen((char *)vcLinkName.arr);

ctx = this->ctx_;

EXEC SQL CONTEXT USE :ctx;

/*TODO 自有变量赋值*/

ACE_OS::memset(&v_sysdate, 0x00, sizeof(v_sysdate));

EXEC SQL AT :vcLinkName

SELECT to_char(sysdate, 'YYYY-MM-DD HH24:MI:SS') INTO :v_sysdate

FROM DUAL;

CLogger::createinstance()->logdebugmsg("[%s]\n", (char *)v_sysdate.arr);

return RT_OK;

notfound:

CLogger::createinstance()->logdebugmsg("[%s]：DML_DEMO_1() ERROR：No record exist\n", this->db_name_.c_str());

return RT_NG;

sqlerr:

return (SqlError(&sqlca, "DML_DEMO_1()"));

}

/*********************************************************************************************

*功能：INSERT INTO示例

*输入：NONE

*输出：NONE

*返回：RT_OK：成功，RT_NG：失败

*修改记录：NONE

*********************************************************************************************/

int CConnection::DML_DEMO_2(int i)

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

EXEC SQL WHENEVER NOT FOUND GOTO notfound;

if (this->ctx_ == NULL) return RT_NG;

if (this->db_connected_ == false) return RT_NG;

EXEC SQL BEGIN DECLARE SECTION;

VARCHAR vcLinkName[64]; /*数据库连接别名*/

sql_context ctx = NULL; /*数据库连接上下文*/

VARCHAR dyn_stmt[1024];

EXEC SQL END DECLARE SECTION;

ACE_OS::memset(&vcLinkName, 0x00, sizeof(vcLinkName));

ACE_OS::strncpy((char *)vcLinkName.arr, this->db_name_.c_str(), this->db_name_.length());

vcLinkName.len = ACE_OS::strlen((char *)vcLinkName.arr);

ctx = this->ctx_;

EXEC SQL CONTEXT USE :ctx;

ACE_OS::memset(&dyn_stmt, 0x00, sizeof(dyn_stmt));

/*TODO 自有变量赋值*/

dyn_stmt.len = ACE_OS::snprintf((char *)dyn_stmt.arr, sizeof(dyn_stmt.arr), "insert into TB1(COL1, COL2) values(%d, sysdate)", i);

CLogger::createinstance()->logdebugmsg("SQL:[%s]\n", dyn_stmt.arr);

EXEC SQL AT :vcLinkName EXECUTE IMMEDIATE :dyn_stmt;

if (sqlca.sqlcode == 0)

{

CLogger::createinstance()->logdebugmsg("insert into TB1 table success\n");

}

else

{

CLogger::createinstance()->logdebugmsg("insert into TB1 table failure\n");

}

EXEC SQL AT :vcLinkName COMMIT WORK;

return RT_OK;

notfound:

CLogger::createinstance()->logdebugmsg("[%s]：DML_DEMO_2() ERROR：No record exist\n", this->db_name_.c_str());

return RT_NG;

sqlerr:

return (SqlError(&sqlca, "DML_DEMO_2()"));

}

/*********************************************************************************************

*功能：PREPARE SELECT示例

*输入：NONE

*输出：NONE

*返回：RT_OK：成功，RT_NG：失败

*修改记录：NONE

*********************************************************************************************/

int CConnection::DML_DEMO_3(int i)

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

/*EXEC SQL WHENEVER NOT FOUND GOTO notfound;*/

if (this->ctx_ == NULL) return RT_NG;

if (this->db_connected_ == false) return RT_NG;

EXEC SQL BEGIN DECLARE SECTION;

VARCHAR vcLinkName[64]; /*数据库连接别名*/

sql_context ctx = NULL; /*数据库连接上下文*/

int v_col1;

VARCHAR v_col2[24];

VARCHAR dyn_stmt[1024];

EXEC SQL END DECLARE SECTION;

ACE_OS::memset(&vcLinkName, 0x00, sizeof(vcLinkName));

ACE_OS::strncpy((char *)vcLinkName.arr, this->db_name_.c_str(), this->db_name_.length());

vcLinkName.len = ACE_OS::strlen((char *)vcLinkName.arr);

ctx = this->ctx_;

EXEC SQL CONTEXT USE :ctx;

/*TODO 自有变量赋值*/

ACE_OS::memset(&dyn_stmt, 0x00, sizeof(dyn_stmt));

dyn_stmt.len = ACE_OS::snprintf((char *)dyn_stmt.arr, sizeof(dyn_stmt.arr), "SELECT COL1, to_char(COL2, 'YYYY-MM-DD HH24:MI:SS') FROM TB1 WHERE COL1=%d", i);

CLogger::createinstance()->logdebugmsg("SQL:[%s]\n", dyn_stmt.arr);

EXEC SQL AT :vcLinkName DECLARE S STATEMENT;

EXEC SQL AT :vcLinkName PREPARE S FROM :dyn_stmt;

EXEC SQL AT :vcLinkName DECLARE C_TB1_1 CURSOR FOR S;

EXEC SQL AT :vcLinkName OPEN C_TB1_1;

for (;;)

{

v_col1 = 0;

ACE_OS::memset(&v_col2, 0x00, sizeof(v_col2));

EXEC SQL WHENEVER NOT FOUND DO BREAK;

EXEC SQL FETCH C_TB1_1 INTO :v_col1, :v_col2;

if (sqlca.sqlcode != 0) break;

CLogger::createinstance()->logdebugmsg("(%d)：COL2=[%s]\n",

v_col1,

v_col2.arr);

}

EXEC SQL AT :vcLinkName CLOSE C_TB1_1;

EXEC SQL AT :vcLinkName COMMIT WORK;

return RT_OK;

notfound:

CLogger::createinstance()->logdebugmsg("[%s]：DML_DEMO_3() ERROR：No record exist\n", this->db_name_.c_str());

return RT_NG;

sqlerr:

return (SqlError(&sqlca, "DML_DEMO_3()"));

}

/*********************************************************************************************

*功能：EXECUTE PROCEDURE示例

*输入：存储过程名, 存储过程入参

*输出：存储过程返回值

*返回：RT_OK：成功，RT_NG：失败

*修改记录：NONE

*********************************************************************************************/

int CConnection::DML_DEMO_4(char* inputparam, char* outputparam)

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

EXEC SQL WHENEVER NOT FOUND GOTO notfound;

if (this->ctx_ == NULL) return RT_NG;

if (this->db_connected_ == false) return RT_NG;

EXEC SQL BEGIN DECLARE SECTION;

VARCHAR vcLinkName[64]; /*数据库连接别名*/

sql_context ctx = NULL; /*数据库连接上下文*/

VARCHAR v_input[512];

VARCHAR v_output[512];

EXEC SQL END DECLARE SECTION;

ACE_OS::memset(&vcLinkName, 0x00, sizeof(vcLinkName));

ACE_OS::strncpy((char *)vcLinkName.arr, this->db_name_.c_str(), this->db_name_.length());

vcLinkName.len = ACE_OS::strlen((char *)vcLinkName.arr);

ctx = this->ctx_;

EXEC SQL CONTEXT USE :ctx;

/*TODO 自有变量赋值*/

v_input.len = ACE_OS::snprintf((char *)v_input.arr, sizeof(v_input.arr),"%s",inputparam);

ACE_OS::memset(&v_output, 0x00, sizeof(v_output));

/*执行PL/SQL块*/

EXEC SQL AT :vcLinkName EXECUTE

BEGIN

sp_test(:v_input, :v_output);

END;

END-EXEC;

if (sqlca.sqlcode == 0)

{

ACE_OS::snprintf((char *)outputparam, v_output.len, "%s", v_output.arr);

outputparam[ v_output.len + 1] = '\0';

CLogger::createinstance()->logdebugmsg("storage procedure (sp_test) success, result=%s\n", outputparam);

}

else

{

CLogger::createinstance()->logdebugmsg("storage procedure (sp_test) failure\n");

}

EXEC SQL AT :vcLinkName COMMIT WORK;

return RT_OK;

notfound:

CLogger::createinstance()->logdebugmsg("[%s]：DML_DEMO_4() ERROR：No record exist\n", this->db_name_.c_str());

return RT_NG;

sqlerr:

return (SqlError(&sqlca, "DML_DEMO_4()"));

}

/*********************************************************************************************

*功能：PREPARE PL/SQL块示例

*输入：NONE

*输出：NONE

*返回：RT_OK：成功，RT_NG：失败

*修改记录：NONE

*********************************************************************************************/

int CConnection::DML_DEMO_5(char* spname, char* inputparam, char* outputparam)

{

#undef SQLCA

EXEC SQL INCLUDE SQLCA;

EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

EXEC SQL WHENEVER NOT FOUND GOTO notfound;

if (this->ctx_ == NULL) return RT_NG;

if (this->db_connected_ == false) return RT_NG;

EXEC SQL BEGIN DECLARE SECTION;

VARCHAR vcLinkName[64]; /*数据库连接别名*/

sql_context ctx = NULL; /*数据库连接上下文*/

VARCHAR v_input[512];

VARCHAR v_output[512];

VARCHAR dyn_stmt[1024];

EXEC SQL END DECLARE SECTION;

ACE_OS::memset(&vcLinkName, 0x00, sizeof(vcLinkName));

ACE_OS::strncpy((char *)vcLinkName.arr, this->db_name_.c_str(), this->db_name_.length());

vcLinkName.len = ACE_OS::strlen((char *)vcLinkName.arr);

ctx = this->ctx_;

EXEC SQL CONTEXT USE :ctx;

/*TODO 自有变量赋值*/

ACE_OS::memset(&dyn_stmt, 0x00, sizeof(dyn_stmt));

dyn_stmt.len = ACE_OS::snprintf((char *)dyn_stmt.arr, sizeof(dyn_stmt.arr), "BEGIN %s(:v_input,:v_output); END;", spname);

v_input.len = ACE_OS::snprintf((char *)v_input.arr, sizeof(v_input), "%s", inputparam);

ACE_OS::memset(&v_output, 0x00, sizeof(v_output));

//CLogger::createinstance()->logdebugmsg("SQL: [%s]\n", dyn_stmt.arr);

EXEC SQL AT :vcLinkName DECLARE SS STATEMENT;

EXEC SQL AT :vcLinkName PREPARE SS FROM :dyn_stmt;

EXEC SQL AT :vcLinkName EXECUTE SS USING :v_input, :v_output;

if (sqlca.sqlcode == 0)

{

ACE_OS::snprintf((char *)outputparam, v_output.len, "%s", v_output.arr);

outputparam[ v_output.len + 1] = '\0';

CLogger::createinstance()->logdebugmsg("storage procedure (%s) success and result=%s\n", spname, outputparam);

}

else

{

CLogger::createinstance()->logdebugmsg("storage procedure (%s) failure\n", spname);

}

EXEC SQL AT :vcLinkName COMMIT WORK;

return RT_OK;

notfound:

CLogger::createinstance()->logdebugmsg("[%s]：DML_DEMO_5() ERROR：No record exist\n", this->db_name_.c_str());

return RT_NG;

sqlerr:

return (SqlError(&sqlca, "DML_DEMO_5()"));

}

cconnectionpool:

#pragma once

#include "Connection.h"

#include "ace/Synch.h"

#include

using namespace std;

typedef list CONNECTIONLIST;

class CConnectionpool : ACE_Event_Handler

{

public:

CConnectionpool(string dbstring, string dbname);

CConnectionpool(string dbstring, string dbname,int maxconn, int minconn, int m_keepalive);

~CConnectionpool(void);

private:

CONNECTIONLIST m_idlelist;

CONNECTIONLIST m_busylist;

string m_dbstring;

string m_dbname;

int m_maxconn;

int m_minconn;

int m_keepalive;

ACE_Thread_Mutex m_mutex;

ACE_Condition *m_pcondition;

bool active_;

private:

CConnection* applyfor();

bool payback(CConnection* pconn);

bool removefromidlelist(CConnection* pconn);

int addtimer(CConnection *pconn);

int removetimer(CConnection *pconn);

virtual int handle_timeout(const ACE_Time_Value &tv, const void *arg);

int getconnectionsize();

public:

bool start();

bool stop();

int executesp(char* spname, char* inputparam, char* outparam);

void output();

bool getactive();

};

#include "Connectionpool.h"

#include "ace/Reactor.h"

#include "Logger.h"

CConnectionpool::CConnectionpool(string dbstring, string dbname)

{

m_dbstring = dbstring;

m_dbname = dbname;

m_minconn = 2;

m_maxconn = 4;

m_keepalive = 10;

m_pcondition = new ACE_Condition(m_mutex);

}

CConnectionpool::CConnectionpool(string dbstring, string dbname, int minconn, int maxconn, int keepalive)

{

m_dbstring = dbstring;

m_dbname = dbname;

m_minconn = minconn;

m_maxconn = maxconn;

m_keepalive = keepalive;

m_pcondition = new ACE_Condition(m_mutex);

}

CConnectionpool::~CConnectionpool(void)

{

delete m_pcondition;

}

bool CConnectionpool::start()

{

bool result = false;

if (CConnection::multi_thread() == RT_OK)

{

active_ = true;

result = true;

}

return result;

}

bool CConnectionpool::stop()

{

active_ = false;

while(m_busylist.size() != 0)

{

ACE_OS::sleep(1);

}

printf("all connections are idle, we can destroy them\n");

typedef CONNECTIONLIST::iterator ITERATOR;

ITERATOR LI;

for(LI = m_idlelist.begin(); LI != m_idlelist.end();)

{

removetimer(*LI);

(*LI)->disconnect();

(*LI)->stop();

delete (*LI);

LI = m_idlelist.erase(LI);

}

return true;

}

CConnection* CConnectionpool::applyfor()

{

m_mutex.acquire();

CConnection *pconn = NULL;

if (m_idlelist.size() > 0)

{

pconn = m_idlelist.front();

m_idlelist.pop_front();

m_busylist.push_back(pconn);

//删除定时器

removetimer(pconn);

}

else

{

int idle = m_idlelist.size();

int busy = m_busylist.size();

int all = idle + busy;

if (all < m_maxconn)

{

pconn = new CConnection(m_dbstring, m_dbname);

pconn->start();

pconn->reconnect();

m_busylist.push_back(pconn);

}

else

{

while(m_idlelist.size() == 0)

{

m_pcondition->signal();

m_pcondition->wait();

}

pconn = m_idlelist.front();

m_idlelist.pop_front();

m_busylist.push_back(pconn);

//删除定时器

removetimer(pconn);

}

m_mutex.release();

return pconn;

}

bool CConnectionpool::payback(CConnection* pconn)

{

m_mutex.acquire();

typedef CONNECTIONLIST::iterator ITERATOR;

ITERATOR LI;

bool find = false;

for(LI = m_busylist.begin(); LI != m_busylist.end();)

{

if (*LI == pconn)

{

LI = m_busylist.erase(LI);

find = true;

}

else

{

LI++;

}

if (find)

{

m_idlelist.push_back(pconn);

pconn->setidletimepoint();

//启动定时器

addtimer(pconn);

m_pcondition->signal();

}

m_mutex.release();

return find;

}

int CConnectionpool::getconnectionsize()

{

m_mutex.acquire();

int idle = m_idlelist.size();

int busy = m_busylist.size();

int all = idle + busy;

m_mutex.release();

return all;

}

bool CConnectionpool::removefromidlelist(CConnection* pconn)

{

m_mutex.acquire();

typedef CONNECTIONLIST::iterator ITERATOR;

ITERATOR LI;

bool find = false;

CConnection *ptemp = NULL;

for(LI = m_idlelist.begin(); LI != m_idlelist.end();)

{

if (*LI == pconn)

{

pconn->disconnect();

pconn->stop();

delete pconn;

m_idlelist.erase(LI);

find = true;

break;

}

m_mutex.release();

return find;

}

int CConnectionpool::executesp(char* spname, char* inputparam, char* outparam)

{

int ret = -1;

if (!active_) return ret;

CConnection *pconn = NULL;

pconn = applyfor();

if (pconn != NULL)

{

pconn->addinvoke();

ret = pconn->DML_DEMO_5(spname, inputparam, outparam);

}

payback(pconn);

return ret;

}

void CConnectionpool::output()

{

m_mutex.acquire();

typedef CONNECTIONLIST::iterator ITERATOR;

ITERATOR LI;

int idle = m_idlelist.size();

int busy = m_busylist.size();

int all = idle + busy;

printf("total=%d\n", all);

printf("idle=%d\n", idle);

printf("busy=%d\n", busy);

printf("........idle list........\n");

for(LI = m_idlelist.begin(); LI != m_idlelist.end(); LI++)

{

(*LI)->output();

}

printf("........busy list........\n");

for(LI = m_busylist.begin(); LI != m_busylist.end(); LI++)

{

(*LI)->output();

}

m_mutex.release();

}

int CConnectionpool::addtimer(CConnection *pconn)

{

ACE_Time_Value tv(this->m_keepalive, 0);

int timerid = ACE_Reactor::instance()->schedule_timer(this, (void*)pconn, tv);

pconn->settimerid(timerid);

return timerid;

}

int CConnectionpool::removetimer(CConnection *pconn)

{

return ACE_Reactor::instance()->cancel_timer(pconn->gettimerid());

}

int CConnectionpool::handle_timeout(const ACE_Time_Value &tv, const void *arg)

{

CConnection *pconn = (CConnection*)arg;

CLogger::createinstance()->logdebugmsg("handle_timeout current=%d connection=%08x timerid=%d ok\n", getconnectionsize(), pconn, pconn->gettimerid());

if (getconnectionsize() > m_minconn)

{

removefromidlelist(pconn);

}

return 0;

}

bool CConnectionpool::getactive()

{

return active_;

}

cclienttask

#pragma once

#include "ace/Task.h"

#include "ace/Synch.h"

#include "Connectionpool.h"

class CClienttask : public ACE_Task

{

public:

CClienttask(void);

CClienttask(CConnectionpool* connpool, int execount);

~CClienttask(void);

public:

virtual int open();

virtual int svc();

virtual int close();

private:

ACE_thread_t threads[0x04];

CConnectionpool* m_pconnpool;

int m_execount;

};

#include "Clienttask.h"

#include "Logger.h"

CClienttask::CClienttask(void)

{

}

CClienttask::CClienttask(CConnectionpool* connpool, int execount)

{

m_pconnpool = connpool;

m_execount = execount;

}

CClienttask::~CClienttask(void)

{

}

int CClienttask::open()

{

return activate(THR_NEW_LWP, 4, 0, ACE_DEFAULT_THREAD_PRIORITY, -1, this, 0, 0, 0, threads);

}

int CClienttask::svc()

{

if (ACE_Thread::self() == threads[0])

{

CLogger::createinstance()->logdebugmsg("watch thread started, threadid=%d\n", threads[0]);

while(true)

{

int command = 0;

scanf_s("%d", &command);

if(command == 1)

{

m_pconnpool->output();

}

else if(command == 2)

{

m_pconnpool->stop();

}

else if (ACE_Thread::self() == threads[1])

{

CLogger::createinstance()->logdebugmsg("client task started, threadid=%d\n", threads[1]);

int i = 0;

while(i < m_execount && m_pconnpool->getactive())

{

char input[100];

sprintf_s(input, 100, "%05dwangxu%05d", threads[1], i);

char output[100];

m_pconnpool->executesp("sp_test", input, output);

i++;

}

else if (ACE_Thread::self() == threads[2])

{

CLogger::createinstance()->logdebugmsg("client task started, threadid=%d\n", threads[2]);

int i = 0;

while(i < m_execount && m_pconnpool->getactive())

{

char input[100];

sprintf_s(input, 100, "%05dwangxu%05d", threads[2], i);

char output[100];

m_pconnpool->executesp("sp_test", input, output);

i++;

}

else if (ACE_Thread::self() == threads[3])

{

CLogger::createinstance()->logdebugmsg("client task started, threadid=%d\n", threads[3]);

int i = 0;

while(i < m_execount && m_pconnpool->getactive())

{

char input[100];

sprintf_s(input, 100, "%05dwangxu%05d", threads[3], i);

char output[100];

m_pconnpool->executesp("sp_test", input, output);

i++;

}

return 0;

}

int CClienttask::close()

{

return 0;

}

CLogger

#pragma once

#include "ace/Activation_Queue.h"

#include "ace/Method_Request.h"

#include "ace/Task.h"

#include "ace/Future.h"

#include "ace/Auto_Ptr.h"

#include

using namespace std;

class CLogger : public ACE_Task

{

public:

/*log level*/

enum LEVEL

{

DEBUG = 0x00,

INFO = 0x01,

WARN = 0x02,

FAULT = 0x03

};

/*output direct*/

enum DIRECTOR

{

SCREENOUT = 0x00,

FILEOUT = 0x01,

BOTH = 0x02

};

/*log mode*/

enum MODE

{

TEST = 0x00,

RUN = 0x01

};

/*whether the log will be split*/

enum SPLIT

{

ONE = 0x00,

FOUR = 0x01

};

/*delete log automatic or manual*/

enum MANAGER

{

AUTODEL = 0x00,

MANUALDEL = 0x01

};

public:

CLogger(void);

CLogger(LEVEL level, DIRECTOR director, MODE mode, SPLIT split, MANAGER manager);

~CLogger(void);

int logdebugmsg_i(const char* fmt, ...);

int loginfomsg_i(const char* fmt, ...);

int logwarnmsg_i(const char* fmt, ...);

int logfaultmsg_i(const char* fmt, ...);

ACE_Future logdebugmsg(const char* fmt, ...);

ACE_Future loginfomsg(const char* fmt, ...);

ACE_Future logwarnmsg(const char* fmt, ...);

ACE_Future logfaultmsg(const char* fmt, ...);

void setparam(LEVEL level, DIRECTOR director, MODE mode, SPLIT split, MANAGER manager);

virtual int open();

virtual int close();

virtual int svc();

static CLogger* createinstance();

private:

static CLogger* _instance;

ACE_thread_t threads[0x01];

ACE_Activation_Queue m_activation_queue;

private:

LEVEL m_level;

DIRECTOR m_director;

MODE m_mode;

SPLIT m_split;

MANAGER m_manager;

string m_directory;

void createlogdirectory();

string getdatetime();

string getdate();

void closefilehandle();

FILE* getonefilehandle();

FILE* getdebugfilehandle();

FILE* getinfofilehandle();

FILE* getwarnfilehandle();

FILE* getfaultfilehandle();

FILE* m_fpfourdebug;

string m_filenamedebug;

FILE* m_fpfourinfo;

string m_filenameinfo;

FILE* m_fpfourwarn;

string m_filenamewarn;

FILE* m_fpfourfault;

string m_filenamefault;

FILE* m_fponelog;

string m_filenamelog;

public:

void setlevel(LEVEL level);

LEVEL getlevel();

void setdirector(DIRECTOR director);

DIRECTOR getdirector();

void setmode(MODE mode);

MODE getmode();

void setsplit(SPLIT split);

SPLIT getsplit();

void setmanager(MANAGER manager);

MANAGER getmanager();

};

#include

#include "Logger.h"

#include "Logdebugmsg_MO.h"

#include "Loginfomsg_MO.h"

#include "Logwarnmsg_MO.h"

#include "Logfaultmsg_MO.h"

CLogger* CLogger::_instance = 0;

CLogger* CLogger::createinstance()

{

if (_instance == 0)

{

_instance = new CLogger;

}

return _instance;

}

CLogger::CLogger(void)

{

m_level = CLogger::DEBUG;

m_director = CLogger::BOTH;

m_mode = CLogger::TEST;

m_split = CLogger::FOUR;

m_manager = CLogger::AUTODEL;

m_fpfourdebug = NULL;

m_fpfourinfo = NULL;

m_fpfourwarn = NULL;

m_fpfourfault = NULL;

m_fponelog = NULL;

m_filenamedebug = "null";

m_filenameinfo = "null";

m_filenamewarn = "null";

m_filenamefault = "null";

m_filenamelog = "null";

createlogdirectory();

}

CLogger::CLogger(LEVEL level, DIRECTOR director, MODE mode, SPLIT split, MANAGER manager)

{

m_level = level;

m_director = director;

m_mode = mode;

m_split = split;

m_manager = manager;

m_fpfourdebug = NULL;

m_fpfourinfo = NULL;

m_fpfourwarn = NULL;

m_fpfourfault = NULL;

m_fponelog = NULL;

m_filenamedebug = "null";

m_filenameinfo = "null";

m_filenamewarn = "null";

m_filenamefault = "null";

m_filenamelog = "null";

createlogdirectory();

}

void CLogger::closefilehandle()

{

if (m_fpfourdebug != NULL)

{

fclose(m_fpfourdebug);

m_fpfourdebug = NULL;

m_filenamedebug = "null";

}

if (m_fpfourinfo != NULL)

{

fclose(m_fpfourinfo);

m_fpfourinfo = NULL;

m_filenameinfo = "null";

}

if (m_fpfourwarn != NULL)

{

fclose(m_fpfourwarn);

m_fpfourwarn = NULL;

m_filenamewarn = "null";

}

if (m_fpfourfault != NULL)

{

fclose(m_fpfourfault);

m_fpfourfault = NULL;

m_filenamefault = "null";

}

if (m_fponelog != NULL)

{

fclose(m_fponelog);

m_fponelog = NULL;

m_filenamelog = "null";

}

CLogger::~CLogger(void)

{

closefilehandle();

}

void CLogger::setlevel(LEVEL level)

{

closefilehandle();

m_level = level;

}

CLogger::LEVEL CLogger::getlevel()

{

return m_level;

}

void CLogger::setdirector(DIRECTOR director)

{

closefilehandle();

m_director = director;

}

CLogger::DIRECTOR CLogger::getdirector()

{

return m_director;

}

void CLogger::setmode(MODE mode)

{

closefilehandle();

m_mode = mode;

}

CLogger::MODE CLogger::getmode()

{

return m_mode;

}

void CLogger::setsplit(SPLIT split)

{

closefilehandle();

m_split = split;

}

CLogger::SPLIT CLogger::getsplit()

{

return m_split;

}

void CLogger::setmanager(MANAGER manager)

{

m_manager = manager;

}

CLogger::MANAGER CLogger::getmanager()

{

return m_manager;

}

string CLogger::getdatetime()

{

time_t current;

current = time(NULL);

struct tm pdatetime;

int error = localtime_s(&pdatetime, ¤t) ;

char datetime[100];

memset(datetime, 0x00, 100);

sprintf_s(datetime, 100, "%04d-%02d-%02d %02d:%02d %02d",

pdatetime.tm_year + 1900,

pdatetime.tm_mon + 1,

pdatetime.tm_mday,

pdatetime.tm_hour,

pdatetime.tm_min,

pdatetime.tm_sec);

return string(datetime);

}

string CLogger::getdate()

{

time_t current;

struct tm pdatetime;

time(¤t);

int error = localtime_s(&pdatetime, ¤t) ;

char date[100];

memset(date, 0x00, 100);

sprintf_s(date, 100, "%04d-%02d-%02d",

pdatetime.tm_year + 1900,

pdatetime.tm_mon + 1,

pdatetime.tm_mday);

return string(date);

}

int CLogger::logdebugmsg_i(const char* fmt, ...)

{

if (getlevel() > CLogger::DEBUG) return 0;

va_list ap;

va_start(ap, fmt);

if (getdirector() == CLogger::SCREENOUT)

{

vfprintf(stdout, fmt, ap);

}

else

{

if (getsplit() == CLogger::ONE)

{

m_fponelog = getonefilehandle();

vfprintf(m_fponelog, fmt, ap);

if (getmode() == CLogger::TEST)

{

fclose(m_fponelog);

m_fponelog = NULL;

}

else

{

m_fpfourdebug = getdebugfilehandle();

vfprintf(m_fpfourdebug, fmt, ap);

if (getmode() == CLogger::TEST)

{

fclose(m_fpfourdebug);

m_fpfourdebug = NULL;

}

if (getdirector() == CLogger::BOTH)

{

vfprintf(stdout, fmt, ap);

}

va_end(ap);

return 0;

}

int CLogger::loginfomsg_i(const char* fmt, ...)

{

if (getlevel() > CLogger::INFO) return 0;

va_list ap;

va_start(ap, fmt);

if (getdirector() == CLogger::SCREENOUT)

{

vfprintf(stdout, fmt, ap);

}

else

{

if (getsplit() == CLogger::ONE)

{

m_fponelog = getonefilehandle();

vfprintf(m_fponelog, fmt, ap);

if (getmode() == CLogger::TEST)

{

fclose(m_fponelog);

m_fponelog = NULL;

}

else

{

m_fpfourinfo = getinfofilehandle();

vfprintf(m_fpfourinfo, fmt, ap);

if (getmode() == CLogger::TEST)

{

fclose(m_fpfourinfo);

m_fpfourinfo = NULL;

}

if (getdirector() == CLogger::BOTH)

{

vfprintf(stdout, fmt, ap);

}

va_end(ap);

return 0;

}

int CLogger::logwarnmsg_i(const char* fmt, ...)

{

if (getlevel() > CLogger::WARN) return 0;

va_list ap;

va_start(ap, fmt);

if (getdirector() == CLogger::SCREENOUT)

{

vfprintf(stdout, fmt, ap);

}

else

{

if (getsplit() == CLogger::ONE)

{

m_fponelog = getonefilehandle();

vfprintf(m_fponelog, fmt, ap);

if (getmode() == CLogger::TEST)

{

fclose(m_fponelog);

m_fponelog = NULL;

}

else

{

m_fpfourwarn = getwarnfilehandle();

vfprintf(m_fpfourwarn, fmt, ap);

if (getmode() == CLogger::TEST)

{

fclose(m_fpfourwarn);

m_fpfourwarn = NULL;

}

if (getdirector() == CLogger::BOTH)

{

vfprintf(stdout, fmt, ap);

}

va_end(ap);

return 0;

}

int CLogger::logfaultmsg_i(const char* fmt, ...)

{

if (getlevel() > CLogger::FAULT) return 0;

va_list ap;

va_start(ap, fmt);

if (getdirector() == CLogger::SCREENOUT)

{

vfprintf(stdout, fmt, ap);

}

else

{

if (getsplit() == CLogger::ONE)

{

m_fponelog = getonefilehandle();

vfprintf(m_fponelog, fmt, ap);

if (getmode() == CLogger::TEST)

{

fclose(m_fponelog);

m_fponelog = NULL;

}

else

{

m_fpfourfault = getfaultfilehandle();

vfprintf(m_fpfourfault, fmt, ap);

if (getmode() == CLogger::TEST)

{

fclose(m_fpfourfault);

m_fpfourfault = NULL;

}

if (getdirector() == CLogger::BOTH)

{

vfprintf(stdout, fmt, ap);

}

va_end(ap);

return 0;

}

void CLogger::createlogdirectory()

{

if (m_director == CLogger::SCREENOUT) return;

string fulldir = "..\\log";

if (_access(fulldir.c_str(), 0) == -1)

{

printf("create %s\n", fulldir.c_str());

_mkdir(fulldir.c_str());

}

fulldir = "..\\log\\debug";

if (_access(fulldir.c_str(), 0) == -1)

{

printf("create %s\n", fulldir.c_str());

_mkdir(fulldir.c_str());

}

fulldir = "..\\log\\info";

if (_access(fulldir.c_str(), 0) == -1)

{

printf("create %s\n", fulldir.c_str());

_mkdir(fulldir.c_str());

}

fulldir = "..\\log\\warn";

if (_access(fulldir.c_str(), 0) == -1)

{

printf("create %s\n", fulldir.c_str());

_mkdir(fulldir.c_str());

}

fulldir = "..\\log\\fault";

if (_access(fulldir.c_str(), 0) == -1)

{

printf("create %s\n", fulldir.c_str());

_mkdir(fulldir.c_str());

}

FILE* CLogger::getonefilehandle()

{

string filename = "..\\log\\" + getdate() + ".log";

if ((filename.compare(m_filenamelog) == 0) && (m_fponelog != NULL))

{

}

else if((filename.compare(m_filenamelog) == 0) && (m_fponelog == NULL))

{

fopen_s(&m_fponelog, filename.c_str(), "a+");

}

else if((filename.compare(m_filenamelog) != 0) && (m_fponelog != NULL))

{

fclose(m_fponelog);

m_fponelog = NULL;

fopen_s(&m_fponelog, filename.c_str(), "a+");

m_filenamelog = filename;

}

else if((filename.compare(m_filenamelog) != 0) && (m_fponelog == NULL))

{

fopen_s(&m_fponelog, filename.c_str(), "a+");

m_filenamelog = filename;

}

return m_fponelog;

}

FILE* CLogger::getdebugfilehandle()

{

string filename = "..\\log\\debug\\" + getdate() + ".dlog";

if ((filename.compare(m_filenamedebug) == 0) && (m_fpfourdebug != NULL))

{

}

else if((filename.compare(m_filenamedebug) == 0) && (m_fpfourdebug == NULL))

{

fopen_s(&m_fpfourdebug, filename.c_str(), "a+");

}

else if((filename.compare(m_filenamedebug) != 0) && (m_fpfourdebug != NULL))

{

fclose(m_fpfourdebug);

m_fpfourdebug = NULL;

fopen_s(&m_fpfourdebug, filename.c_str(), "a+");

m_filenamedebug = filename;

}

else if((filename.compare(m_filenamedebug) != 0) && (m_fpfourdebug == NULL))

{

fopen_s(&m_fpfourdebug, filename.c_str(), "a+");

m_filenamedebug = filename;

}

return m_fpfourdebug;

}

FILE* CLogger::getinfofilehandle()

{

string filename = "..\\log\\info\\" + getdate() + ".ilog";

if ((filename.compare(m_filenameinfo) == 0) && (m_fpfourinfo != NULL))

{

}

else if((filename.compare(m_filenameinfo) == 0) && (m_fpfourinfo == NULL))

{

fopen_s(&m_fpfourinfo, filename.c_str(), "a+");

}

else if((filename.compare(m_filenameinfo) != 0) && (m_fpfourinfo != NULL))

{

fclose(m_fpfourinfo);

m_fpfourinfo = NULL;

fopen_s(&m_fpfourinfo, filename.c_str(), "a+");

m_filenameinfo = filename;

}

else if((filename.compare(m_filenameinfo) != 0) && (m_fpfourinfo == NULL))

{

fopen_s(&m_fpfourinfo, filename.c_str(), "a+");

m_filenameinfo = filename;

}

return m_fpfourinfo;

}

FILE* CLogger::getwarnfilehandle()

{

string filename = "..\\log\\warn\\" + getdate() + ".wlog";

if ((filename.compare(m_filenamewarn) == 0) && (m_fpfourwarn != NULL))

{

}

else if((filename.compare(m_filenamewarn) == 0) && (m_fpfourwarn == NULL))

{

fopen_s(&m_fpfourwarn, filename.c_str(), "a+");

}

else if((filename.compare(m_filenamewarn) != 0) && (m_fpfourwarn != NULL))

{

fclose(m_fpfourwarn);

m_fpfourwarn = NULL;

fopen_s(&m_fpfourwarn, filename.c_str(), "a+");

m_filenamewarn = filename;

}

else if((filename.compare(m_filenamewarn) != 0) && (m_fpfourwarn == NULL))

{

fopen_s(&m_fpfourwarn, filename.c_str(), "a+");

m_filenamewarn = filename;

}

return m_fpfourwarn;

}

FILE* CLogger::getfaultfilehandle()

{

string filename = "..\\log\\fault\\" + getdate() + ".flog";

if ((filename.compare(m_filenamefault) == 0) && (m_fpfourfault != NULL))

{

}

else if((filename.compare(m_filenamefault) == 0) && (m_fpfourfault == NULL))

{

fopen_s(&m_fpfourfault, filename.c_str(), "a+");

}

else if((filename.compare(m_filenamefault) != 0) && (m_fpfourfault != NULL))

{

fclose(m_fpfourfault);

m_fpfourfault = NULL;

fopen_s(&m_fpfourfault, filename.c_str(), "a+");

m_filenamefault = filename;

}

else if((filename.compare(m_filenamefault) != 0) && (m_fpfourfault == NULL))

{

fopen_s(&m_fpfourfault, filename.c_str(), "a+");

m_filenamefault = filename;

}

return m_fpfourfault;

}

int CLogger::open()

{

return activate(THR_NEW_LWP, 1, 0, ACE_DEFAULT_THREAD_PRIORITY, -1, this, 0, 0, 0, threads);

}

int CLogger::close()

{

return 0;

}

int CLogger::svc()

{

while(true)

{

auto_ptr mo(m_activation_queue.dequeue());

if (mo->call() == -1)

break;

}

return 0;

}

ACE_Future CLogger::logdebugmsg(const char* fmt, ...)

{

char logmsg1[1024];

memset(logmsg1, 0x00, 1024);

va_list ap;

va_start(ap, fmt);

_vsnprintf_s(logmsg1, 1024, fmt, ap);

va_end(ap);

char logmsg2[1024];

memset(logmsg2, 0x00, 1024);

sprintf_s(logmsg2, 1024, "[%s] %s", getdatetime().c_str(), logmsg1);

ACE_Future resultant_future;

CLogdebugmsg_MO *pmo = new CLogdebugmsg_MO(this, logmsg2, resultant_future);

m_activation_queue.enqueue(pmo);

return resultant_future;

}

ACE_Future CLogger::loginfomsg(const char* fmt, ...)

{

char logmsg1[1024];

memset(logmsg1, 0x00, 1024);

va_list ap;

va_start(ap, fmt);

_vsnprintf_s(logmsg1, 1024, fmt, ap);

va_end(ap);

char logmsg2[1024];

memset(logmsg2, 0x00, 1024);

sprintf_s(logmsg2, 1024, "[%s] %s", getdatetime().c_str(), logmsg1);

ACE_Future resultant_future;

m_activation_queue.enqueue(new CLoginfomsg_MO(this, logmsg2, resultant_future));

return resultant_future;

}

ACE_Future CLogger::logwarnmsg(const char* fmt, ...)

{

char logmsg1[1024];

memset(logmsg1, 0x00, 1024);

va_list ap;

va_start(ap, fmt);

_vsnprintf_s(logmsg1, 1024, fmt, ap);

va_end(ap);

char logmsg2[1024];

memset(logmsg2, 0x00, 1024);

sprintf_s(logmsg2, 1024, "[%s] %s", getdatetime().c_str(), logmsg1);

ACE_Future resultant_future;

m_activation_queue.enqueue(new CLogwarnmsg_MO(this, logmsg2, resultant_future));

return resultant_future;

}

ACE_Future CLogger::logfaultmsg(const char* fmt, ...)

{

char logmsg1[1024];

memset(logmsg1, 0x00, 1024);

va_list ap;

va_start(ap, fmt);

_vsnprintf_s(logmsg1, 1024, fmt, ap);

va_end(ap);

char logmsg2[1024];

memset(logmsg2, 0x00, 1024);

sprintf_s(logmsg2, 1024, "[%s] %s", getdatetime().c_str(), logmsg1);

ACE_Future resultant_future;

m_activation_queue.enqueue(new CLogfaultmsg_MO(this, logmsg2, resultant_future));

return resultant_future;

}

CLogdebugmsg_MO

#pragma once

#include "ace\method_request.h"

#include "Logger.h"

class CLogdebugmsg_MO : public ACE_Method_Request

{

public:

CLogdebugmsg_MO(CLogger* logger, const char* fmt, ACE_Future &future_result);

~CLogdebugmsg_MO(void);

private:

CLogger * m_plogger;

char* m_fmt;

ACE_Future m_future_result;

public:

int call();

};

#include "Logdebugmsg_MO.h"

CLogdebugmsg_MO::CLogdebugmsg_MO(CLogger* logger, const char* fmt, ACE_Future &future_result)

{

int length = strlen(fmt) + 1;

m_fmt = new char[length];

memcpy_s(m_fmt, length, fmt, length);

m_plogger = logger;

m_future_result = future_result;

}

CLogdebugmsg_MO::~CLogdebugmsg_MO(void)

{

delete []m_fmt;

}

int CLogdebugmsg_MO::call()

{

return m_future_result.set(m_plogger->logdebugmsg_i(m_fmt));

}

CLoginfomsg_MO#pragma once

#include "ace\method_request.h"

#include "Logger.h"

class CLoginfomsg_MO : public ACE_Method_Request

{

public:

CLoginfomsg_MO(CLogger* logger, const char* fmt, ACE_Future &future_result);

~CLoginfomsg_MO(void);

private:

CLogger * m_plogger;

char* m_fmt;

ACE_Future m_future_result;

public:

int call();

};

#include "Loginfomsg_MO.h"

CLoginfomsg_MO::CLoginfomsg_MO(CLogger* logger, const char* fmt, ACE_Future &future_result)

{

int length = strlen(fmt) + 1;

m_fmt = new char[length];

memcpy_s(m_fmt, length, fmt, length);

m_plogger = logger;

m_future_result = future_result;

}

CLoginfomsg_MO::~CLoginfomsg_MO(void)

{

delete []m_fmt;

}

int CLoginfomsg_MO::call()

{

return m_future_result.set(m_plogger->loginfomsg_i(m_fmt));

}

CLogwarnmsg_MO#pragma once

#include "ace\method_request.h"

#include "Logger.h"

class CLogwarnmsg_MO : public ACE_Method_Request

{

public:

CLogwarnmsg_MO(CLogger* logger, const char* fmt, ACE_Future &future_result);

~CLogwarnmsg_MO(void);

private:

CLogger * m_plogger;

char* m_fmt;

ACE_Future m_future_result;

public:

int call();

};

#include "Logwarnmsg_MO.h"

CLogwarnmsg_MO::CLogwarnmsg_MO(CLogger* logger, const char* fmt, ACE_Future &future_result)

{

int length = strlen(fmt) + 1;

m_fmt = new char[length];

memcpy_s(m_fmt, length, fmt, length);

m_plogger = logger;

m_future_result = future_result;

}

CLogwarnmsg_MO::~CLogwarnmsg_MO(void)

{

delete []m_fmt;

}

int CLogwarnmsg_MO::call()

{

return m_future_result.set(m_plogger->logwarnmsg_i(m_fmt));

}

CLogwarnmsg_MO

#pragma once

#include "ace\method_request.h"

#include "Logger.h"

class CLogfaultmsg_MO : public ACE_Method_Request

{

public:

CLogfaultmsg_MO(CLogger* logger, const char* fmt, ACE_Future &future_result);

~CLogfaultmsg_MO(void);

private:

CLogger * m_plogger;

char* m_fmt;

ACE_Future m_future_result;

public:

int call();

};

#include "Logfaultmsg_MO.h"

CLogfaultmsg_MO::CLogfaultmsg_MO(CLogger* logger, const char* fmt, ACE_Future &future_result)

{

int length = strlen(fmt) + 1;

m_fmt = new char[length];

memcpy_s(m_fmt, length, fmt, length);

m_plogger = logger;

m_future_result = future_result;

}

CLogfaultmsg_MO::~CLogfaultmsg_MO(void)

{

delete []m_fmt;

}

int CLogfaultmsg_MO::call()

{

return m_future_result.set(m_plogger->logfaultmsg_i(m_fmt));

}

Proc

// Proc.cpp : Defines the entry point for the console application.

#include "stdafx.h"

#include

#include "Connectionpool.h"

#include "ace/Reactor.h"

#include "Clienttask.h"

#include "Logger.h"

int main(int argc, char* argv[])

{

ACE_Reactor::instance();

ACE_OS::sleep(2);

CLogger::createinstance()->open();

CConnectionpool connpool("ucs/ucs@ucs", "ucs", 5, 10, 10);

connpool.start();

ACE_OS::sleep(2);

CClienttask clienttask(&connpool, 1);

clienttask.open();

while(1)

{

ACE_Reactor::instance()->handle_events();

}

return 0;

}

weixin_39615643

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
遇到oracle错误24909,使用Pro C++实现数据库连接池采用多线程方式访问oracle数据库 | 学步园...

数据库连接作为一种资源，我们的应用必须对之进行行之有效的管理。我们在访问数据库的时候，一般传统上采用先建立连接，然后使用该连接访问数据库，在使用完毕后，关闭该连接。这是我们经常采用的方法。该方法的好处是使用简单，不用对连接进行任何管理。但随之带来的缺点也就出现了，在应用需要频繁访问数据库的时候，这种方法就会使程序的效率十分低下，甚至有时候是不能满足应用的需要的。随着数据库连接池技术出现了，我们的应...
复制链接

扫一扫