c语言自己实现线程池功能

最新推荐文章于 2024-05-25 09:55:15 发布
最新推荐文章于 2024-05-25 09:55:15 发布
阅读量366 收藏
点赞数
分类专栏： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jenie/article/details/106133009
版权

上一次讲了使用libzdb数据连接池的用法，如果不想用库，想自己实现，也可以。就不需要加库了。

直接上代码

sqlpool.h

#ifndef __SQLPOOL_H_
#define __SQLPOOL_H_

#define IP_LEN      15
#define DBNAME_LEN  64
#define DBUSER_LEN  64
#define PASSWD_LEN  64
#define POOL_MAX_NUMBER 20


typedef struct _SQL_NODE SQL_NODE;                /*连接节点*/
typedef struct _SQL_CONN_POOL SQL_CONN_POOL;      /*连接池*/

/*连接节点*/
typedef struct _SQL_NODE{
    MYSQL            fd;                  /* mysql对象文件描述符 */
    MYSQL            *mysql_sock;         /* 指向已经连接的MYSQL的指针 */
    pthread_mutex_t  lock;                /* 互斥锁*/
    int              used;                /* 使用标志 */
    int              index;               /* 下标 */
    enum{
        DB_DISCONN, DB_CONN
    }sql_state;

}SQL_NODE;

/*连接池*/
typedef struct _SQL_CONN_POOL{
    int        shutdown;                   /*是否关闭*/
    SQL_NODE   sql_pool[POOL_MAX_NUMBER];  /* 一堆连接 */
    int        pool_number;                /* 连接数量 */
    int        busy_number;                /*被获取了的连接数量*/
    char       ip[IP_LEN+1];               /* 数据库的ip */
    int        port;                       /* 数据库的port,一般是3306 */
    char       db_name[DBNAME_LEN+1];      /* 数据库的名字 */
    char       user[DBUSER_LEN+1];         /* 用户名 */
    char       passwd[PASSWD_LEN+1];       /* 密码 */
}SQL_CONN_POOL;

/*创建连接池*/
SQL_CONN_POOL *sql_pool_create(int connect_pool_number, char ip[], int port,
                               char db_name[], char user[], char passwd[]);
/*节点创建连接*/
int create_db_connect(SQL_CONN_POOL *sp, SQL_NODE *node);
/*销毁连接池*/
void sql_pool_destroy(SQL_CONN_POOL *sp);
/*取出一个未使用的连接*/
SQL_NODE *get_db_connect(SQL_CONN_POOL *sp);
/*归回连接*/
void release_node(SQL_CONN_POOL *sp, SQL_NODE *node);
/*增加或删除连接*/
SQL_CONN_POOL *changeNodeNum(SQL_CONN_POOL *sp, int op);

#endif

sqlpool.c

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <mysql/mysql.h>
#include <pthread.h>
#include "sqlpool.h"

//sql_pool_create(POOL_MAX_NUMBER, "localhost", 3306, "ceshi", "root", "qc123456");  
/*创建连接池*/
SQL_CONN_POOL *sql_pool_create(int connect_pool_number, char ip[], int port,
                               char db_name[], char user[], char passwd[])
{
    SQL_CONN_POOL *sp = NULL;
    if (connect_pool_number < 1)
    {
        printf("connect_pool_number < 1. defalut 1 \n");
        connect_pool_number = 1;
    }
    if ((sp=(SQL_CONN_POOL *)malloc(sizeof(SQL_CONN_POOL))) == NULL)
    {
        printf("malloc SQL_CONN_POOL error.\n");
        return NULL;
    }

    sp->shutdown    = 0; //开启连接池
    sp->pool_number = 0;
    sp->busy_number = 0;
    strcpy(sp->ip, ip);
    sp->port = port;
    strcpy(sp->db_name, db_name);
    strcpy(sp->user, user);
    strcpy(sp->passwd, passwd);

    /*创建连接*/
    if (connect_pool_number > POOL_MAX_NUMBER)
        connect_pool_number = POOL_MAX_NUMBER;

    int index =0;
    for (index=0; index < connect_pool_number; index++)
    {
        //创建失败
        if (0 != create_db_connect(sp, &sp->sql_pool[index]))
        {
            //销毁连接池
            sql_pool_destroy(sp);
            return NULL;
        }
        //创建成功
        sp->sql_pool[index].index = index;
        sp->pool_number++;
        printf("create database pool connect:-%d-.\n",sp->sql_pool[index].index);
    }

    return sp;
}
/*节点创建连接*/
int create_db_connect(SQL_CONN_POOL *sp, SQL_NODE *node)
{
    int opt=1;
    int res=0; //0正常 -1初始化失败 1 连接失败

    do
    {
        if (sp->shutdown == 1)
            return -1;
        /*加锁*/
        pthread_mutex_init(&node->lock, NULL);

        /*初始化mysql对象*/
        if (NULL == mysql_init(&node->fd))
        {
            printf("mysql init error. \n");
            res = -1;
            break;
        }
        if (!(node->mysql_sock = mysql_real_connect(
                &node->fd, sp->ip, sp->user, sp->passwd, sp->db_name, sp->port, NULL, 0)))
        {
            printf("can not connect to mysql.\n");
            node->sql_state = DB_DISCONN;
            res = 1;
            break;
        }
        node->used = 0;
        node->sql_state = DB_CONN;
        //设置自动连接开启
        mysql_options(&node->fd, MYSQL_OPT_RECONNECT, &opt);
        opt = 3;
        //设置连接超时时间为3s，3s未连接成功则超时
        mysql_options(&node->fd, MYSQL_OPT_CONNECT_TIMEOUT, &opt);
        res = 0;

    }while(0);

    return res;
}
/*销毁连接池*/
void sql_pool_destroy(SQL_CONN_POOL *sp)
{
    printf("destroy sql pool ... ... \n");
    sp->shutdown = 1; //关闭连接池
    int index = 0;
    for (index=0; index < sp->pool_number; index++)
    {
        if (NULL != sp->sql_pool[index].mysql_sock)
        {
            mysql_close(sp->sql_pool[index].mysql_sock);
            sp->sql_pool[index].mysql_sock = NULL;
        }
        sp->sql_pool[index].sql_state = DB_DISCONN;
        sp->pool_number--;
    }
}
/*取出一个未使用的连接*/
SQL_NODE *get_db_connect(SQL_CONN_POOL *sp)
{
    //获取一个未使用的连接，用随机值访问index，保证每次访问每个节点的概率基本相同
    int start_index = 0, index = 0, i;
    int ping_res;

    if (sp->shutdown == 1)
        return NULL;

    srand((int)time(0)); //根据当前时间生成随机数
    start_index = rand() % sp->pool_number; //访问的开始地址

    for (i=0; i < sp->pool_number; i++)
    {
        index = (start_index + i) % sp->pool_number;

        if (!pthread_mutex_trylock(&sp->sql_pool[index].lock))
        {
            if (DB_DISCONN == sp->sql_pool[index].sql_state)
            {
                //重新连接
                if (0 != create_db_connect(sp, &(sp->sql_pool[index])))
                {
                    //重新连接失败
                    release_node(sp, &(sp->sql_pool[index]));
                    continue;
                }
            }
            //检查服务器是否关闭了连接
            ping_res = mysql_ping(sp->sql_pool[index].mysql_sock);
            if (0 != ping_res)
            {
                printf("mysql ping error.\n");
                sp->sql_pool[index].sql_state = DB_DISCONN;
                release_node(sp, &(sp->sql_pool[index]));
            }
            else
            {
                sp->sql_pool[index].used = 1;
                sp->busy_number++;//被获取的数量增1
                break ;  //只需要一个节点
            }
        }
    }

    if (i == sp->pool_number)
    {
        return NULL;
    }
    else
    {
        return &(sp->sql_pool[index]);
    }

}
/*归回连接*/
void release_node(SQL_CONN_POOL *sp, SQL_NODE *node)
{
    node->used = 0;
    sp->busy_number--;
    pthread_mutex_unlock(&node->lock);
}
/*增加或删除连接*/
SQL_CONN_POOL *changeNodeNum(SQL_CONN_POOL *sp, int op)  //增加或减少5个连接
{
    int Num = 5;
    int index;
    int endindex;

    if (op == 1)  //增加    0减少
    {
        endindex = sp->pool_number + Num;

        /*创建连接*/
        for (index=sp->pool_number; index < endindex; index++)
        {
            //创建失败
            if (0 != create_db_connect(sp, &sp->sql_pool[index]))
            {
                //销毁连接池
                sql_pool_destroy(sp);
                return NULL;
            }
            //创建成功
            sp->sql_pool[index].index = index;                                                           sp->pool_number++;
            printf("create database pool connect:-%d-.\n",sp->sql_pool[index].index);
        }
    }
    else if (op == 0)
    {
        endindex = sp->pool_number - Num -1;
        //减少连接
        for (index=sp->pool_number-1; index>endindex && index>=0; index--)
        {
            if (NULL != sp->sql_pool[index].mysql_sock)
            {
                mysql_close(sp->sql_pool[index].mysql_sock);
                sp->sql_pool[index].mysql_sock = NULL;
            }
            sp->sql_pool[index].sql_state = DB_DISCONN;
            sp->pool_number--;
            printf("delete database pool connect:-%d-.\n",sp->sql_pool[index].index);
        }
    }


    return sp;
}


int main()  
{  
   
  //MYSQL_FIELD *fd;  
    SQL_CONN_POOL *sp = 
    sql_pool_create(10, "localhost", 3306, "edu", "root", "Internet@2014");
    SQL_NODE *node  = get_db_connect(sp);  
    SQL_NODE *node2 = get_db_connect(sp);
			  
    if (NULL == node)  
    {  
       printf("get sql pool node error.\n");  
       return -1;  
    } 
    printf("--%d-- \n", node->index);
    printf("busy--%d--\n", sp->busy_number);
    
    if (mysql_query(&(node->fd), "select * from hy_admin"))
    {
        printf("query error.\n");
        return -1;
    }
    else  
    {  
        printf("succeed!\n");  
    }
    changeNodeNum(sp, 0);//减少
    changeNodeNum(sp, 1);//增加
    sql_pool_destroy(sp);
    return 0;  
} 

[root@VM_0_13_centos db]# ls
db-app  makefile  sqlpool.c  sqlpool.h
[root@VM_0_13_centos db]# ./db-app 
create database pool connect:-0-.
create database pool connect:-1-.
create database pool connect:-2-.
create database pool connect:-3-.
create database pool connect:-4-.
create database pool connect:-5-.
create database pool connect:-6-.
create database pool connect:-7-.
create database pool connect:-8-.
create database pool connect:-9-.
--9-- 
busy--2--
succeed!
delete database pool connect:-9-.
delete database pool connect:-8-.
delete database pool connect:-7-.
delete database pool connect:-6-.
delete database pool connect:-5-.
create database pool connect:-5-.
create database pool connect:-6-.
create database pool connect:-7-.
create database pool connect:-8-.
create database pool connect:-9-.
destroy sql pool ... ... 
[root@VM_0_13_centos db]#

 

jenie
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言 线程池的实现
xfy333的专栏
01-31 1722
为什么需要线程池？ 目前的大多数网络服务器，包括 Web 服务器、Email 服务器以及数据库服务器等都具有一个共同 点，就是单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短。 传统多线程方案中我们采用的服务器模型则是一旦接受到请求之后，即创建一个新的线程，由该 线程执行任务。任务执行完毕后，线程退出，这就是是“即时创建，即时销毁”的策略。尽管与 创建进程相比，创建线程的时间已经大大的缩短，但是如果提交给线程的任务是执行时间较短， 而且执行次数极其频繁...
C笔记 用C语言实现一个线程池
m0_74991361的博客
06-03 216
***仅记录学习过程，谨慎参考****
C语言实现线程池
笔记
01-02 792
C语言标准库中并没有提供线程池的实现，线程池需要手搓
C语言实现线程池功能
遇见你是我最美丽的意外
06-14 5779
1. 线程池基本原理 2. 线程池C语言实现 2.1 线程池的数据结构 #include <stdio.h> #include <pthread.h> #include <stdlib.h> #include <string.h> #include <signal.h> #include <errno.h> #include <unistd.h> typedef struct { void *(*function
【C语言实现线程池】
m0_45463480的博客
05-25 397
创建一个线程池是提高多线程应用程序性能的有效方法。一个线程池中包含一定数量的工作线程，这些线程可以复用来处理多个任务，避免了频繁创建和销毁线程所带来的开销。下面是一个基础的线程池实现的框架，使用C语言和POSIX线程库(pthread)。这个简单的线程池会轮询并执行放入队列的任务。 代码说明 结构体定义:线程池工作函数:线程池创建函数:添加任务函数:销毁线程池函数:示例任务:这个基础代码可以满足大部分简单的线程池需求，但在实际应用中，你可能还会需要考虑：这个基础代码是一个很好的起点，你可以在其基础上根据
线程池_详解C语言实现的线程池
AlexanderGan的博客
12-15 2302
一、线程池功能定义：   频繁的创建和启动线程会带来很大的开销，所以为了提高多线程任务处理效率，才有了线程池。其实池化技术都有一个特点，无论是内存池、线程池还是对象池等池化技术主要都是为了提高资源分配效率，预先分配一些资源在池子中，根据需要动态的调整和分配池中的资源（要弄清楚线程池，需要耐心阅读下面的代码哦，代码来自传智播客的教学资料）。   上图是对线程池基本工作原理的描述，但是实际实现还需要管理者线程来对工作线程进行调配，管理者线程不参与工作。线程池需要具备以下基本功能： 1.需要维护一个任务队列，通
[Linux程序设计] C语言实现线程池
weixin_62337145的博客
07-11 910
在linux环境下使用C语言完成线程池的创建。在程序中多次创建线程会占用CPU时间，如何保证一个线程可以复用，提高CPU的利用率，线程池可以解决这些问题。
C语言实现简单的线程池项目（附完整工程文件）
柒枫的博客
09-05 1353
一、引言：通常情况下，多线程编程都是在需要的时候，创建一个新线程，然后让这个线程去完成指定的任务， 完成之后退出(线程相当于是短工)，一般情况下是能够满足我们的需求。 但是当我们需要创建大量的线程的时候，并且执行一个非常简单的任务后线程需要销毁时，比如： 文件夹的COPY 网页服务器的响应 Email邮件服务器等等 那么像上面这些情况下，我们的程序需要面对大量的请求，但是同时这些请求执行的任务又非常的 简单，占用...
c语言实现线程池
zhangke1985的专栏
03-09 320
备注：该线程池源码参考自传直播客培训视频配套资料； 源码：https://pan.baidu.com/s/1zWuoE3q0KT5TUjmPKTb1lw 密码：pp42 引言：线程池是一种多线程处理形式，大多用于高并发服务器上，它能合理有效的利用高并发服务器上的线程资源； 在Unix网络编程中，线程与进程用于处理各项分支子功能，我们通常的操作是：接收消息 ==> 消息分类 ==> 线程创建 ==> 传递消息到子线程 ==> 线程分离 ==> 在子线程中执行任务 ==>
C语言写一个线程池（原理 + 代码）
Royi的学习博客
04-27 744
使用C语言实现一个线程池，包括详细的代码以及原理介绍
【C语言和C++】实现线程池
m0_64560763的博客
05-27 2923
线程，线程池
linux下C语言实现线程池
12-25
接下来，我们将深入探讨如何在Linux环境下用C语言实现线程池。 首先，我们需要了解线程的基本概念。在C语言中，线程是进程内的一个执行单元，每个线程都有自己的程序计数器、栈和局部变量，但共享全局变量和其他...
C语言 Linux Nginx 线程池
06-22
这些元素共同构成了一个高级话题，即如何在Linux环境中使用C语言来实现Nginx服务器的线程池功能。线程池是一种优化资源分配和管理的策略，它预先创建一组线程，当有任务需要执行时，从线程池中取出一个线程来处理...
课程作业-基于C语言实现线程池源码.zip
01-06
课程作业-基于C语言实现线程池源码.zip课程作业-基于C语言实现线程池源码.zip课程作业-基于C语言实现线程池源码.zip课程作业-基于C语言实现线程池源码.zip课程作业-基于C语言实现线程池源码.zip课程作业-基于C语言...
Linux环境下C语言实现简单线程池.zip
最新发布
06-13
在实际开发中，可以参考开源的线程池库，如libThreadPool或自己实现，这将有助于加深对多线程编程和系统资源管理的理解。在学习过程中，记得经常进行单元测试和性能测试，以确保代码的正确性和性能表现。
线程池 threadPool c语言实现
12-05
总的来说，C语言实现的线程池通过合理管理和调度线程，可以提高系统性能，降低资源消耗。对于需要处理大量并发请求的服务器应用或者计算密集型任务，线程池是不可或缺的优化手段。在深入理解线程池的工作原理后，...
MySQL之MVVC简单介绍
jenie的专栏
05-17 5855
1、什么是锁？ 一种保护机制，在多线程的情况下，保证操作数据的正确性与一致性 2、锁有哪些分类？ 悲观锁、乐观锁、独占锁、共享锁、公平锁、非公平锁、分布式锁、自旋锁 3、谈谈悲观锁乐观锁： 指的是看待并发同步的角度，一般结合数据库将，以MySQL为例，悲观锁主要是表锁，行锁和间隙锁，叶锁，读锁，因为这些锁在被触发时会引起线程阻塞，所以叫悲观锁；而乐观锁其实在MySQL中本身不存在，但是MySQL提供了MVCC的机制，支持乐观锁机制 4、什么是MVCC？ 只有在InnoDB引擎下存在，MVCC是.
让nginx支持php7.2（包括nginx,mysql,php的安装等配置）
jenie的专栏
09-24 1052
1 关于php7.2的安装 ，可以查看https://blog.csdn.net/jenie/article/details/108223302 2 mysql源码安装，请查看https://blog.csdn.net/jenie/article/details/108761891 3 nginx的安装 比较简单 ./configure make && make install 全部默认就好了。 以下通过nginx来支持php.其原理就是通过fastcgi协议来调用p...
c语言数据库libzdb库的安装以及使用
jenie的专栏
07-24 881
下载，注意版本，使用3.1版本，如果以上的，可以支持c++17，我使用的不需要支持，搞c++17环境有些麻烦 wget http://www.tildeslash.com/libzdb/dist/libzdb-3.1.tar.gz tar -zxvf libzdb-3.1.tar.gz ./configure make make install ldconfig 以下直接调用 #include <stdio.h> #include <stdlib.h> #in.
linux线程池c语言实现
07-25
在C语言中实现一个简单的线程池可以按照以下步骤进行： 1. 定义线程池结构体：创建一个结构体，包含线程池中的线程数量、任务队列、互斥锁、条件变量等必要的成员。 ```c typedef struct { pthread_t *threads; // 线程数组 int thread_count; // 线程数量 task_queue_t *task_queue; // 任务队列 pthread_mutex_t mutex; // 互斥锁 pthread_cond_t cond; // 条件变量 int shutdown; // 线程池关闭标志 } thread_pool_t; ``` 2. 定义任务队列结构体：创建一个结构体，用于存储任务队列的信息，包括任务数组、任务数量、头尾指针等成员。 ```c typedef struct { task_t **tasks; // 任务数组 int task_count; // 任务数量 int head; // 队列头指针 int tail; // 队列尾指针 } task_queue_t; ``` 3. 定义任务结构体：创建一个结构体，用于存储具体的任务信息，例如任务函数指针和参数。 ```c typedef struct { void (*function)(void *); // 任务函数指针 void *argument; // 任务参数 } task_t; ``` 4. 初始化线程池：创建线程池，并初始化线程数组、任务队列、互斥锁、条件变量等。 5. 添加任务：将任务添加到任务队列中，并通过条件变量通知线程池中的线程有新任务可执行。 6. 线程函数：线程池中的线程函数，循环从任务队列中取出任务并执行。 7. 等待线程池任务完成：可以通过条件变量等待所有任务执行完毕。 8. 销毁线程池：释放线程池中的资源，包括线程数组、任务队列、互斥锁、条件变量等。 这是一个简单的线程池实现的框架，你可以根据自己的需求进行具体的功能扩展和优化。注意在并发环境中使用互斥锁和条件变量来保证线程安全。希望对你有所帮助！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值