数据库连接池实现

最新推荐文章于 2024-04-21 23:14:13 发布
最新推荐文章于 2024-04-21 23:14:13 发布
阅读量349 收藏
点赞数
分类专栏： 小组件 文章标签： 数据库 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45826058/article/details/126644975
版权

目录

介绍

  • 简单实现数据库连接池，对连接的管理采用双向链表。

代码

  • 管理已连接的连接用到双向链表
  • 目录结构
    01

double_llist.h

#ifndef DOUBLE_LLIST__
#define DOUBLE_LLIST__

typedef void d_llist_node_t;
typedef void d_llist_t;

int llist_init(d_llist_t **llist);

typedef int (*compare)(void *a, void *b);
int llist_insert(d_llist_t *llist, void *key, compare cmp);

d_llist_node_t *llist_pop_first(d_llist_t *llist);
d_llist_node_t *llist_pop_last(d_llist_t *llist);

d_llist_node_t *llist_head_look(d_llist_t *llist);
d_llist_node_t *llist_tail_look(d_llist_t *llist);

int llist_destroy(d_llist_t *llist);

typedef int (*traver)(void *node);
int llist_traver(d_llist_t *llist, traver tvr);

// typedef int (*compare)(void *a, void *b);
int llist_check(d_llist_t *llist, compare cmp);

// new
d_llist_node_t *llist_find_node(d_llist_t *llist, void *key, compare cmp);

int llist_delete_node(d_llist_t *llist, void *key, compare cmp);

#endif

double_llist.c

#include <stdio.h>
#include <stdlib.h>

#include "./double_llist.h"


typedef struct llist_node_s{

    void *key;
    struct llist_node_s *prev;
    struct llist_node_s *next;

}llist_node_t;

typedef struct llist_s{

    llist_node_t *head;
    llist_node_t *tail;

}llist_t;




int llist_init(void **llist){

    llist_t *me = NULL;

    me = (llist_t*)malloc(sizeof(*me));
    if(me == NULL){
        return -1;
    }

    me->head = NULL;
    me->tail = NULL;

    *llist = me;

    return 0;
}

/*
    typedef int (*compare)(void *a, void *b);
    compare return value:
        1 : a > b
        -1 : a < b
        0 : a == b
*/
int llist_insert(d_llist_t *llist, void *key, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = me->head;
    llist_node_t *node_ = NULL;

    node_ = (llist_node_t*)malloc(sizeof(*node_));
    if(node_ == NULL){
        return -1;
    }
    node_->next = NULL;
    node_->prev = NULL;
    node_->key = key;

    int res = 0;

    while(cur != NULL){

        res = cmp(key, cur->key);
        if(res > 0){
            cur = cur->next;
        }else{  // res < 0 || res == 0
            break;
        }

    }


    if(cur == NULL){
        // insert on tail
        // or head = tail = NULL, llist is null
        node_->prev = me->tail;
        node_->next = NULL;
        if(me->tail != NULL){
            me->tail->next = node_;
            me->tail = node_;
        }else{
            me->tail = node_;
        }
        if(me->head == NULL){
            me->head = node_;
        }

    }else if(cur == me->head){
        // insert on head
        node_->next = me->head;
        node_->prev = NULL;
        me->head->prev = node_;
        me->head = node_;

    }else{

        node_->next = cur;
        node_->prev = cur->prev;
        cur->prev->next = node_;
        cur->prev = node_;

    }

    return 0;
}

void *llist_pop_first(void *llist){

    llist_t *me = llist;
    llist_node_t *cur = me->head;

    if(cur == NULL){

        return NULL;

    }else if(cur->next == NULL){

        me->head = NULL;
        me->tail = NULL;

    }else{

        me->head = cur->next;
        me->head->prev = NULL;

    }

    void *ret = cur->key;

    free(cur);

    return ret;
}

void *llist_pop_last(void *llist){

    llist_t *me = llist;
    llist_node_t *cur = me->tail;

    if(cur == NULL){
        return NULL;
    }else if(cur->prev == NULL){
        me->head = NULL;
        me->tail = NULL;
    }else{
        me->tail = cur->prev;
        me->tail->next = NULL;
    }


    void *ret = cur->key;

    free(cur);

    return ret;
}

int llist_destroy(void *llist){

    llist_t *me = llist;
    llist_node_t *cur = me->head, *temp = NULL;

    while(cur != NULL){

        temp = cur->next;

        free(cur->key);
        free(cur);

        cur = temp;

    }

    free(me);

    llist = NULL;

    return 0;
}

/*
typedef int (*traver)(void *node);
*/
int llist_traver(void *llist, traver tvr){

    llist_t *me = llist;
    llist_node_t *cur = me->head;

    while(cur != NULL){

        tvr(cur->key);

        cur = cur->next;
        if(cur){
            printf(" -> ");
        }
    }
    printf("\n");

    return 0;
}


int llist_check(void *llist, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = me->head;

    if(cur != NULL && cur->next != NULL){
        cur = cur->next;
    }else{
        return 0;
    }

    while(cur != NULL){

        if(cmp(cur->key, cur->prev->key) < 0){
            return -1;
        }
        cur = cur->next;

    }

    return 0;
}




d_llist_node_t *llist_head_look(d_llist_t *llist){

    llist_t *me = llist;

    if(me->head == NULL){
        return NULL;
    }

    return me->head->key;
}
d_llist_node_t *llist_tail_look(d_llist_t *llist){

    llist_t *me = llist;

    if(me->tail == NULL){
        return NULL;
    }

    return me->tail->key;
}


// new
d_llist_node_t *llist_find_node(d_llist_t *llist, void *key, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = me->head;
    int res = 0;

    

    while(1){
        if (cur == NULL){
            return NULL;
        }

        res = cmp(key, cur->key);
        if(res == 0){
            return cur;
        }

        cur = cur->next;
    }


    return NULL;
}

int llist_delete_node(d_llist_t *llist, void *key, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = llist_find_node(llist, key, cmp);

    if(cur == NULL){
        return -1;
    }

    if(cur->prev == NULL && cur->next == NULL){

        me->head = NULL;
        me->tail = NULL;
        
    }else if(cur->prev == NULL){
        me->head = cur->next;
        me->head->prev = NULL;
    }else if(cur->next == NULL){
        me->tail = cur->prev;
        me->tail->next = NULL;
    }else{
        cur->next->prev = cur->prev;
        cur->prev->next = cur->next;
    }

#if 1
    free(cur->key);
    free(cur);
#endif

    return 0;
}

connect_pool.h

#ifndef _CONNECT_POOL_H__
#define _CONNECT_POOL_H__

#include "pthread.h"
#include <mysql/mysql.h>

#include "../double_llist/double_llist.h"

typedef struct connect_pool_st{

    d_llist_t *connect;

    int connect_idel;
    int connect_total;

    pthread_mutex_t mutex;

    char *host;
    char *username;
    char *passwd;
    char *database;
    short port;

}connect_pool_t;

typedef struct sql_msg_st{

    MYSQL *mysql; 
    MYSQL_ROW row;
    MYSQL_RES *res;

}sql_msg_t;

int connect_pool_init(connect_pool_t **pool, int conn_num, const char *host,
                      const char *username, const char *passwd, const char *database,
                      short port);


sql_msg_t *get_a_connection(connect_pool_t *pool);

int return_a_connection(connect_pool_t *pool, sql_msg_t *will);

int connect_pool_destroy(connect_pool_t *pool);

#endif

connect_pool.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <pthread.h>

#include "./connect_pool.h"

static int my_compare(void *a, void *b){
    return 1;
}

static int connect_init_(connect_pool_t *pool){

    connect_pool_t *me = pool;
    int i = 0;

    for(i = 0; i < me->connect_total; i++){
        
        sql_msg_t *cur = (sql_msg_t*)malloc(sizeof(*cur));

        cur->mysql = mysql_init(NULL);

        if(mysql_real_connect(cur->mysql, me->host, me->username, me->passwd, me->database, me->port, NULL, 0) == 0){
            puts(me->host);
            puts(me->username);
            puts(me->passwd);
            puts(me->database);
            printf("port = %d\n", me->port);
            printf("connect error.\n");
            perror("connect()");
            return -1;
        }else{
            printf("[%d] connect success.\n", i + 1);
        }

        cur->res = NULL;
        cur->row = NULL;

        llist_insert(pool->connect, cur, my_compare);

    }
    
    return 0;
}

int connect_pool_init(connect_pool_t **pool, int conn_num, const char *host,
                      const char *username, const char *passwd, const char *database,
                      short port){
    
    connect_pool_t *me = (connect_pool_t*)malloc(sizeof(*me));
    if(me == NULL){
        return -1;
    }

    llist_init(&me->connect);

    me->connect_total = conn_num;
    me->host = (void*)malloc(strlen(host));
    strcpy(me->host, host);
    me->username = (void*)malloc(strlen(username));
    strcpy(me->username, username);
    me->passwd = (void*)malloc(strlen(passwd));
    strcpy(me->passwd, passwd);
    me->database = (void*)malloc(strlen(database));
    strcpy(me->database, database);
    me->port = port;

    pthread_mutex_t mutex_unused = PTHREAD_MUTEX_INITIALIZER;
    memcpy(&me->mutex, &mutex_unused, sizeof(mutex_unused));

    connect_init_(me);

    *pool = me;

    return 0;
}


sql_msg_t *get_a_connection(connect_pool_t *pool){

    connect_pool_t *me = pool;

    pthread_mutex_lock(&me->mutex);
    sql_msg_t *ret = llist_pop_first(me->connect);
    pthread_mutex_unlock(&me->mutex);

    return ret;
}


int return_a_connection(connect_pool_t *pool, sql_msg_t *will){

    connect_pool_t *me = pool;

    pthread_mutex_lock(&me->mutex);
    int ret = llist_insert(me->connect, will, my_compare);
    pthread_mutex_unlock(&me->mutex);

    return ret;
}



int connect_pool_destroy(connect_pool_t *pool){

    connect_pool_t *me = pool;

    free(me->host);
    free(me->username);
    free(me->passwd);
    free(me->database);

    sql_msg_t *cur = NULL;

    while(1){

        pthread_mutex_lock(&me->mutex);
        cur = llist_pop_first(me->connect);
        pthread_mutex_unlock(&me->mutex);
        if(cur == NULL){
            break;
        }

        mysql_close(cur->mysql);
        printf("A connection is closed.\n");
        free(cur);

    }

    free(me);
    
    pool = NULL;

    return 0;
}

test.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "./connect_pool.h"

int my_traver(void *a){
    printf("+");
    return 0;
}

int main(){

    connect_pool_t *pool;

    connect_pool_init(&pool, 10, "192.168.23.1", "saika", "1", "test", 3306);

    sql_msg_t *cur = NULL;
    for (int x = 0; x < 1024; x++)
    {
        cur = get_a_connection(pool);
        if (cur == NULL)
        {
            printf("without get.\n");
        }
        else
        {
            char *query = "select no from user;";
            if (mysql_real_query(cur->mysql, query, strlen(query)) != 0)
            {
                printf("select false\n");
            }
            else
            {
                cur->res = mysql_store_result(cur->mysql);
                while ((cur->row = mysql_fetch_row(cur->res)) != NULL)
                {
                    printf("%s\n", *cur->row);
                }
            }
            // return_a_connection(pool, cur);
        }
    }

    llist_traver(pool->connect, my_traver);

    return_a_connection(pool, cur);

    llist_traver(pool->connect, my_traver);
    

    pause();

    connect_pool_destroy(pool);
    
    exit(0);
}

总结

已实现功能

  1. 获取一个连接
  2. 归还一个连接

待实现功能

  1. 对连接池内的连接数的动态增加和减少
remoter.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
后端学习（二）实现自己的数据库连接池
iii_ooo的博客
03-22 2194
本文将介绍一个简易的数据库连接池，来便于理解其原理。
连接池的三种实现方式
huolan52的博客
04-22 3564
关于连接池：关于数据库的连接过程，我们经常用到的是JDBC技术，一般对于初学者来说都是通过定义一个连接方法和一个释放资源的方法，可是这样的方式存在一个弊端，就是当连接数非常多的时候，我们不断使用连接和关闭，这样比较消耗系统资源，这时候我们就需要引入连接池。 关于连接池的思想是，我们先创建一个池子，之后创建连接存放到池子中去，这时候我们再从池子中直接通过拿取连接来进行使用，使用完之后再归还给池子即...
Java高级编程！一文手把手带你实现自己的数据库连接池！
最新发布
greatming666的博客
04-21 1234
数据库连接池使用了池化的技术，可以复用数据库连接，减少了重复开启连接和关闭连接带来的性能损耗，减轻了数据库的压力，提高了服务器的处理效能。本文将带领读者从零开始使用java从零实现一个数据库连接池。
数据库连接池
热门推荐
ChineseSoftware的博客
03-11 1万+
一、关于数据库连接池 一个普通的 java 程序，要查询数据库的数据，基本流程是这样的： 可以看到，进行一次查询，要进行很多次网络交互，这样的缺点是： 网络IO多； 响应时间长，导致QPS降低； 频繁创建连接和关闭连接，浪费数据库资源，影响服务器性能。 什么是数据库连接池？ 顾名思义，就是一个池子，里面放着数据库连接，应用服务需要的时候就去池子里面拿，用完之后归还给池子。数据库连接池负责分配、管理、释放数据库连接，它允许应用服务重复使用数据库连接，而非重新建立。 使用连接池之后，流程是这样的： 数据
数据库连接池原理之(一)：通俗易懂的数据库连接池原理以及实现机制讲解
yygr的博客
04-13 1522
https://blog.csdn.net/guobinhui/article/details/85157805?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefa
数据库连接池java代码实现
01-09
用java代码详细描述了连接池的原理实现，注释也非常详细
c# mysql数据库连接池实现
03-24
本文将深入探讨如何在C#中使用MySQL数据库连接池。 首先，我们需要了解什么是数据库连接池。数据库连接池是一种资源管理技术，它预先创建并维护一定数量的数据库连接，当应用需要时，可以从池中获取连接，使用完毕...
thinkphp5-swoole 数据库连接池实现
08-06
基于tp5的swoole支持，对th5的connection进行改造，使用Swoole\Coroutine\MySQL重写了基于swoole的PDO接口，实现了mysql的数据库连接池，本地测试可用。使用时，替换thinkphp/library/think/db/Connection.php，并...
Java实现数据库连接池简易教程
09-02
本文将介绍一个简单的数据库连接池实现，包括设计思路和关键类的讲解。 首先，我们来看一下数据库连接池的核心类： 1. **ConnectionParam**：这是一个配置类，用于存储数据库连接的相关参数，如驱动名（driver）、...
druid数据库连接池实现jar包.zip
01-23
Druid数据库连接池是阿里巴巴开源的一款高效、强大的数据库连接池组件，它在Java应用程序中用于管理数据库连接，提高数据库访问性能并优化资源利用。这个压缩包包含`druid-1.1.22.jar`和`druid.properties`两个文件...
简易的数据库连接池实现
01-21
自定义实现的数据库连接池，并进行加锁，保证线程安全，适合初学者学习。
数据库连接池代码及步骤
07-25
数据库连接池代码及步骤
数据库连接池代码实现
呼卓宇的博客
03-03 990
数据库连接池代码实现 步骤 大体步骤和之前封装JDBC差不多，不懂的可以去看看上一篇blog。 所以今天我简单描述一下。 在src目录创建一个配置文件db.properties DRIVER:com.mysql.jdbc.Driver URL:jdbc:mysql://localhost:3306/db214 USER:root PASSWORD:123456 ...
自己实现一个高并发可用的数据库连接池
aloysjun的博客
03-21 8083
简介 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。 为什么要用连接池呢？ 如果按照单个连接来进行数据库操作，在高并发的情况下会导致数据库连接数耗尽的问题，而且单个连接的频繁创建和关闭，极大地增加了数据库的...
自己实现一个数据库连接池
大道至简
11-18 4459
        尽管很多Web服务器厂商已经在服务器内嵌入了数据池的实现,比如Tomcat的DBCP数据库连接池.不过由于其内部的机制开发者并不熟悉.从而出现了Bug不知道该如何去解决.        一直以来我也不喜欢用第三方的开发包,所以就自己参考着一本书实现了一个数据库连接池.并且可扩充性也可以.更重要的是自己写的数据库连接池.即便出现了Bug也比较容易找出来.      下面是数据
java之实现自己的数据库连接池
qq_32459653的博客
08-26 2096
最近仿mybatis写了一个自己的orm框架 项目已上传到github上 https://github.com/skybluehhx/MYORM.git，既然是orm框架肯定需要事务管理器和数据库连接池，下面将介绍我自己实现一个连接池 （主要借助阻塞队列） 首先定义一个接口，给出线程池的基本功能 package Pools; import java.sql.Connection; /**...
谈谈数据库连接池的原理
369540808
11-06 1919
谈谈数据库连接池的原理 帅宏军 这次我们采取技术演进的方式来谈谈数据库连接池的技术出现过程及其原理，以及当下最流行的开源数据库连接池jar包。 一.早期我们怎么进行数据库操作 1.原理：一般来说，java应用程序访问数据库的过程...
数据库连接池的实现及原理
细节决定成败
08-14 1086
对于一个简单的数据库应用，由于对于数据库的访问不是很频繁。这时可以简单地在需要访问数据库时，就新创建一个连接，用完后就关闭它，这样做也不会带来什么明显的性能上的开销。但是对于一个复杂的数据库应用，情况就完全不同了。频繁的建立、关闭连接，会极大的减低系统的性能，因为对于连接的使用成了系统性能的瓶颈。 连接复用。通过建立一个数据库连接池以及一套连接使用管理策略，使得一个数据库连接可以得到高效
Javaweb数据库连接池实现
03-22
Javaweb数据库连接池可以通过使用Apache Commons DBCP或者C3P0等第三方库来实现。这些库提供了一些配置参数，比如最大连接数、最小连接数、连接超时时间等，可以根据实际需求进行配置。同时，还可以通过使用JNDI来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值