#include <iostream>
|
#include <list>
|
#include <mutex>
|
#include <condition_variable>
|
#include <mysql_driver.h>
|
#include <mysql_connection.h>
|
#include <cppconn/statement.h>
|
#include <cppconn/resultset.h>
|
|
class SQLConnectionPool {
|
private:
|
SQLConnectionPool(int minConns, int maxConns) :
|
minConnections(minConns), maxConnections(maxConns), currentConnections(0) {}
|
|
static SQLConnectionPool* instance;
|
static std::mutex mutex;
|
std::condition_variable cv;
|
int minConnections;
|
int maxConnections;
|
int currentConnections;
|
std::list<std::unique_ptr<sql::Connection>> connections;
|
|
// 创建一个新的数据库连接
|
std::unique_ptr<sql::Connection> createConnection() {
|
try {
|
sql::Driver* driver = sql::mysql::get_mysql_driver_instance();
|
std::unique_ptr<sql::Connection> conn(driver->connect("tcp://127.0.0.1:3306", "username", "password"));
|
conn->setSchema("your_database");
|
return conn;
|
} catch (sql::SQLException &e) {
|
std::cerr << "创建连接错误: " << e.what() << std::endl;
|
return nullptr;
|
}
|
}
|
|
public:
|
// 获取单例实例
|
static SQLConnectionPool* getInstance(int minConns, int maxConns) {
|
std::lock_guard<std::mutex> lock(mutex);
|
if (instance == nullptr) {
|
instance = new SQLConnectionPool(minConns, maxConns);
|
instance->initializePool();
|
}
|
return instance;
|
}
|
|
// 初始化连接池
|
void initializePool() {
|
for (int i = 0; i < minConnections; ++i) {
|
std::unique_ptr<sql::Connection> conn = createConnection();
|
if (conn) {
|
connections.push_back(std::move(conn));
|
currentConnections++;
|
}
|
}
|
}
|
|
// 获取数据库连接
|
std::unique_ptr<sql::Connection> getConnection() {
|
std::unique_lock<std::mutex> lock(mutex);
|
while (connections.empty() && currentConnections >= maxConnections) {
|
cv.wait(lock);
|
}
|
|
std::unique_ptr<sql::Connection> conn;
|
if (!connections.empty()) {
|
conn = std::move(connections.front());
|
connections.pop_front();
|
} else if (currentConnections < maxConnections) {
|
conn = createConnection();
|
if (conn) {
|
currentConnections++;
|
}
|
}
|
return conn;
|
}
|
|
// 归还数据库连接
|
void releaseConnection(std::unique_ptr<sql::Connection>& conn) {
|
std::lock_guard<std::mutex> lock(mutex);
|
if (currentConnections > minConnections) {
|
currentConnections--;
|
} else {
|
connections.push_back(std::move(conn));
|
}
|
cv.notify_one();
|
}
|
};
|
|
std::mutex SQLConnectionPool::mutex;
|
SQLConnectionPool* SQLConnectionPool::instance = nullptr;
|
