C语言简易版线程池

最新推荐文章于 2024-07-30 00:40:15 发布
最新推荐文章于 2024-07-30 00:40:15 发布
阅读量183 收藏 2
点赞数
分类专栏： C/C++ 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42120843/article/details/125267768
版权

C语言版简易线程池

文章目录

背景

若同时有十万个客户端向服务器请求数据，那么我们所需要的资源：

posix标准的线程8M，则1G内存可以开128个线程，16G内存只能开16*128 = 2048个线程，则需要800G左右的内存，显然耗费硬件资源过大，所以需要一种解决方案。

线程池的优点

  • 可以重用已存在的线程，避免线程太多，使得内存耗尽
  • 避免创建和销毁线程的代价
  • 任务与执行相分离

线程池实现的图示

线程池主要由三部分构成:任务队列、执行队列（线程队列）和管理组件

在这里插入图片描述

代码剖析

结构体定义

任务队列和线程队列都是采用了双向链表来实现：

//任务类型
struct nTask{
    //任务实际工作函数
    void (*task_func)(void *arg); 
    void *user_data; //task_func的参数

    //任务队列用双向列表组织起来
    struct nTask *prev;
    struct nTask *next;
};


//线程（执行）类型
struct nWorker{
    pthread_t threadid;
    struct nManager *manager;
    int terminate; //是否终止的标识.1为终止

    struct nWorker *prev;
    struct nWorker *next;
};

链表的插入删除操作分别用宏实现：

//支持层对链表的操作
#define LIST_INSERT(item, list) do{ \
    item->prev = NULL;              \
    item->next = list;              \
    if((list) != NULL) (list)->prev = item; \
    (list) = item;                  \
}while(0)

#define LIST_REMOVE(item, list) do{                         \
    if(item->prev != NULL) item->prev->next = item->next;   \
    if(item->next != NULL) item->next->prev = item->prev;   \
    if(list == item)    list = item->next;                  \
    item->prev = item->next = NULL;                         \
}while(0)

**执行队列和任务队列之间的管理组件就是我们所谓的线程池，**结构体定义如下：

typedef struct nManager{
    struct nTask *tasks; //任务队列
    struct nWorker *workers;//执行队列

    pthread_mutex_t mutex;
    pthread_cond_t cond;
}ThreadPool;

线程池初始化

线程池初始化就是对 除任务队列tasks外（任务时外界添加进来的） 的其他成员进行初始化，在线程池中创建给定数量的线程：

//对线程池pool进行初始化，nWorker是线程池中线程数量(即聘请的柜员数量)
int nThreadPoolCreate(ThreadPool *pool, int numWorkers)
{
    if(pool == NULL)    return -1;
    if(numWorkers < 1)  numWorkers = 1;

    //pool必须要初始化为空，如果是垃圾值下面memcpy会出现段错误
    memset(pool, 0x00, sizeof(ThreadPool));

    //相当于pthread_cond_init()进行初始化
    pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER;
    memcpy(&pool->cond, &blank_cond, sizeof(pthread_cond_t));

    //pthread_mutex_init(&pool->mutex, NULL); // 初始化互斥锁，下方代码功能相同
    pthread_mutex_t blank_mutex = PTHREAD_MUTEX_INITIALIZER;
    memcpy(&pool->mutex, &blank_mutex, sizeof(pthread_mutex_t));


    int i = 0;
    //创建线程
    for(i = 0;i < numWorkers; ++i)
    {
        struct nWorker *worker = (struct nWorker *)malloc(sizeof(struct nWorker));
        if(worker == NULL)
        {
            perror("malloc");
            return -2;
        }
        memset(worker, 0x00, sizeof(struct nWorker));
        worker->manager = pool;//方便线程回调函数的使用

        //创建线程，成功返回0
        //线程回调函数为nThreadPoolCallback
        //参数为：worker
        int ret = pthread_create(&worker->threadid, NULL, nThreadPoolCallback, worker);
        if(ret)
        {
            perror("pthread_create");
            free(worker);
            return -3;
        }

        //printf("LIST_INSERT\n");
        //将线程插入线程链表(队列)头
        LIST_INSERT(worker, pool->workers);
    }

    return 0;
}

线程回调函数实现

线程回调函数的主要功能就是循环等待任务的到来，有任务就执行，没有任务就循环等待：

static void *nThreadPoolCallback(void *arg)
{
    //worker指向某一个线程
    struct nWorker *worker = (struct nWorker *)arg;
    //printf("nThreadPoolCallback\n");

    //有任务执行任务，没任务循环等待
    while(1)
    {
        //这里也能看出nWorker中添加了manager成员的用处，就不用再传nManager对象了
        pthread_mutex_lock(&worker->manager->mutex);
        //无任务时，阻塞等待
        while(worker->manager->tasks == NULL)
        {
            //worker->terminate非0表明所有线程都要销毁了
            if(worker->terminate)   break;  
            //条件等待 
            //会先解除互斥锁让其他线程能够执行，然后阻塞，
            //当被pthread_cond_signal唤醒时，则会解除阻塞并加互斥锁
            pthread_cond_wait(&worker->manager->cond, &worker->manager->mutex);
        } 

        if(worker->terminate)
        {
            //防止死锁
            pthread_mutex_unlock(&worker->manager->mutex);
            break;
        }

        //任务执行，将任务从任务队列中取出
        struct nTask *task = worker->manager->tasks; 
        LIST_REMOVE(task, worker->manager->tasks);
        
        pthread_mutex_unlock(&worker->manager->mutex);
        
        //执行任务
        task->task_func(task);
    }
    free(worker);

}

销毁所有线程

销毁所有线程就是让每一个线程的terminate属性为1，表明要退出，当对应线程回调函数执行到对于该属性判断的时候就会退出循环。

int nThreadPoolDestroy(ThreadPool *pool, int nWorker)
{
    struct nWorker *worker = NULL;
    for(worker = pool->workers;worker != NULL; worker = worker->next)
    {
        worker->terminate = 1; // 使得对应线程执行其回调函数就会退出
    }
    //保证任务执行的时候不会被直接打断（任务执行时也是用的这把互斥锁）
    pthread_mutex_lock(&pool->mutex);
    pthread_cond_broadcast(&pool->cond); // 广播唤醒所有等待任务的nWorker
    pthread_mutex_unlock(&pool->mutex);

    pool->workers = NULL;
    pool->tasks = NULL;
    return 0;
}

添加任务功能

添加任务就是将任务添加进任务链表，并且通过pthread_cond_signal唤醒其中一个线程去执行这个任务：

int nThreadPoolPushTask(ThreadPool *pool, struct nTask *task)
{
    //操作到任务队列和执行队列要加锁 （pool->tasks是共享资源）
    pthread_mutex_lock(&pool->mutex);
    //添加任务
    LIST_INSERT(task, pool->tasks);
    
    //通知回调函数有任务去执行任务
    pthread_cond_signal(&pool->cond); //唤醒一个线程中的wait

    pthread_mutex_unlock(&pool->mutex);
}

可能会出的错误

  1. 结构体变量没有进行清空，导致有值，解决方法：

    ThreadPool     pool = {0}

    或者

    ThreadPool pool;
memset(&pool, 0x00, sizeof(ThreadPool));

  2. 主线程没有等待子线程执行任务结束就退出

解决办法：主线程出口位置添加 getchar()让用户输入一个字符再退出

思考题

了解CAS无锁算法，并写出自己心得体会

完整代码

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

//支持层对链表的操作
#define LIST_INSERT(item, list) do{ \
    item->prev = NULL;              \
    item->next = list;              \
    if((list) != NULL) (list)->prev = item; \
    (list) = item;                  \
}while(0)

#define LIST_REMOVE(item, list) do{                         \
    if(item->prev != NULL) item->prev->next = item->next;   \
    if(item->next != NULL) item->next->prev = item->prev;   \
    if(list == item)    list = item->next;                  \
    item->prev = item->next = NULL;                         \
}while(0)

//任务类型
struct nTask{
    //任务实际工作函数
    void (*task_func)(void *arg); 
    void *user_data; //task_func的参数

    //任务队列用双向列表组织起来
    struct nTask *prev;
    struct nTask *next;
};


//线程（执行）类型
struct nWorker{
    pthread_t threadid;
    struct nManager *manager;
    int terminate; //是否终止的标识.1为终止

    struct nWorker *prev;
    struct nWorker *next;
};

//执行队列和任务队列之间的管理组件
//这就是我们所谓的线程池，就是这个管理组件
typedef struct nManager{
    struct nTask *tasks; //任务队列
    struct nWorker *workers;//执行队列

    pthread_mutex_t mutex;
    pthread_cond_t cond;
}ThreadPool;


//线程回调函数，static表示本文件有效
//回调函数不等于任务！callback ！= task
//每个线程的任务就是循环等待任务到来并执行任务
static void *nThreadPoolCallback(void *arg)
{
    //worker指向某一个线程
    struct nWorker *worker = (struct nWorker *)arg;
    printf("nThreadPoolCallback\n");

    //有任务执行任务，没任务循环等待
    while(1)
    {
        //这里也能看出nWorker中添加了manager成员的用处，就不用再传nManager对象了
        pthread_mutex_lock(&worker->manager->mutex);
        //无任务时，阻塞等待
        while(worker->manager->tasks == NULL)
        {
            //worker->terminate表明所有线程都要销毁了
            if(worker->terminate)   break;  
             //条件等待 
            //会先解除互斥锁让其他线程能够执行，然后阻塞，
            //当被pthread_cond_signal唤醒时，则会解除阻塞并加互斥锁
            pthread_cond_wait(&worker->manager->cond, &worker->manager->mutex);
        } 

        if(worker->terminate)
        {
            //防止死锁
            pthread_mutex_unlock(&worker->manager->mutex);
            break;
        }

        //任务执行，将任务从任务队列中取出
        struct nTask *task = worker->manager->tasks; 
        LIST_REMOVE(task, worker->manager->tasks);
        
        pthread_mutex_unlock(&worker->manager->mutex);
        
        //执行任务
        task->task_func(task);
    }
    free(worker);

}

//对线程池pool进行初始化，numWorkers是线程池中线程数量(即聘请的柜员数量)
int nThreadPoolCreate(ThreadPool *pool, int numWorkers)
{
    if(pool == NULL)    return -1;
    if(numWorkers < 1)  numWorkers = 1;

    //pool必须要初始化为空，如果是垃圾值下面memcpy会出现段错误
    memset(pool, 0x00, sizeof(ThreadPool));

    //相当于pthread_cond_init()进行初始化
    pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER;
    memcpy(&pool->cond, &blank_cond, sizeof(pthread_cond_t));

    //pthread_mutex_init(&pool->mutex, NULL); // 初始化互斥锁，下方代码功能相同
    pthread_mutex_t blank_mutex = PTHREAD_MUTEX_INITIALIZER;
    memcpy(&pool->mutex, &blank_mutex, sizeof(pthread_mutex_t));


    int i = 0;
    //创建线程
    for(i = 0;i < numWorkers; ++i)
    {
        struct nWorker *worker = (struct nWorker *)malloc(sizeof(struct nWorker));
        if(worker == NULL)
        {
            perror("malloc");
            return -2;
        }
        memset(worker, 0x00, sizeof(struct nWorker));
        worker->manager = pool;//方便操作

        //创建线程，成功返回0
        int ret = pthread_create(&worker->threadid, NULL, nThreadPoolCallback, worker);
        if(ret)
        {
            perror("pthread_create");
            free(worker);
            return -3;
        }

        printf("LIST_INSERT\n");
        //将线程插入线程链表(队列)头
        LIST_INSERT(worker, pool->workers);
    }

    return 0;
}

int nThreadPoolDestroy(ThreadPool *pool, int nWorker)
{
    struct nWorker *worker = NULL;
    for(worker = pool->workers;worker != NULL; worker = worker->next)
    {
        worker->terminate = 1; // 使得对应线程执行其回调函数就会退出
    }
    //保证任务执行的时候不会被直接打断（任务执行时也是用的这把互斥锁）
    pthread_mutex_lock(&pool->mutex);
    pthread_cond_broadcast(&pool->cond); // 广播唤醒所有等待任务的nWorker
    pthread_mutex_unlock(&pool->mutex);

    pool->workers = NULL;
    pool->tasks = NULL;
    return 0;
}

//往任务队列添加任务
int nThreadPoolPushTask(ThreadPool *pool, struct nTask *task)
{
    //操作到任务队列和执行队列要加锁 （pool->tasks是共享资源）
    pthread_mutex_lock(&pool->mutex);
    //添加任务
    LIST_INSERT(task, pool->tasks);
    
    //通知回调函数有任务去执行任务
    pthread_cond_signal(&pool->cond); //唤醒一个线程中的wait

    pthread_mutex_unlock(&pool->mutex);
}

#if 1
//线程池初始化线程数量
#define THREADPOOL_INIT_COUNT   20
#define TASK_INIT_SIZE          1000

void task_entry(void *arg)
{
    struct nTask *task = (struct nTask *)arg;
    int idx = *(int *)task->user_data;

    printf("idx: %d\n", idx); 
 
    free(task->user_data);
    free(task);
}

int main(void)
{
    ThreadPool pool = {0};
    //初始化线程池
    nThreadPoolCreate(&pool, THREADPOOL_INIT_COUNT);
    printf("nThreadPoolCreate -- finish\n");

    int i = 0;
    //添加任务
    for(i = 0;i < TASK_INIT_SIZE;i++)
    {
        struct nTask *task = (struct nTask *)malloc(sizeof(struct nTask));
        if(task == NULL)
        {
            perror("malloc");
            exit(1);
        }
        memset(task, 0x00, sizeof(struct nTask));

        task->task_func = task_entry;
        task->user_data = malloc(sizeof(int));
        //先转换为int *类型，再取得指向的值
        *(int *)task->user_data = i;

        nThreadPoolPushTask(&pool, task);
    }

    //为了防止主线程在子线程之前退出
    //让用户输入一个字符
    getchar();
}

#endif
FuzhouJiang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单线程池C语言实现
迷雾江湖 的博客
01-31 1454
一个简单线程池的实现 一、什么是线程池？ 线程池的官方定义： 线程池是一种成熟的线程使用模式。实现由领导者与跟随者模式，半同步半异步模式。线程池的伸缩性对性能有较大的影响。创建太多线程，将会浪费一定的资源，有些线程池未被充分使用。销毁太多线程，将导致之后浪费时间再次创建它们。创建线程太慢，将会导致长时间的等待，性能变差。销毁线程池太慢，导致其他线程资源饥饿。 二
C语言Linux线程池代码
wchajl的博客
09-19 179
Linux线程池
C语言实现简单线程池
weixin_30780221的博客
05-09 400
有时我们会需要大量线程来处理一些相互独立的任务，为了避免频繁的申请释放线程所带来的开销，我们可以使用线程池。下面是一个C语言实现的简单的线程池。 头文件： 1: #ifndef THREAD_POOL_H__ 2: #define THREAD_POOL_H__ 3: 4: #include <pthread.h> ...
[C/C++] 线程池的简单实现
RED_STARRR的博客
02-28 410
1.何为线程池。 把线程池想象成食堂打饭阿姨，每一份饭对应一个线程，线程池的作用便是像打饭阿姨一样在没人的时候等待，一旦有人刷卡（任务到来），阿姨便分发餐盘打菜（分配线程），吃完后再回收餐盘（回收线程）继续等待。当然，阿姨一怒之下也可以把餐盘摔了（结束线程）。当然可能同时有几个窗口（临界资源）进行打饭，所以不可避免的要加锁。 2.线程池的作用。 个人理解，线程池起到一个缓冲区的作用，等需要的时候从池子里拿，不要再放回，避免线程创建销毁的过渡开销，同时对线程起到一个管理作用。已经很重要的起到异步解耦（异
线程池的应用
fuchangyaocool的博客
07-31 273
线程池原理 简单来说就是有一堆已经创建好的线程（最大数目一定），初始时他们都处于空闲状态，当有新的任务进来，从线程池中取出一个空闲的线程处理任务，然后当任务处理完成之后，该线程被重新放回到线程池中，供其他的任务使用，当线程池中的线程都在处理任务时，就没有空闲线程供使用，此时，若有新的任务产生，只能等待线程池中有线程结束任务空闲才能执行，下面是线程池的工作原理图： 线程池的实现原理： 线程池的组成主要分为 3 个部分，这三部分配合工作就可以得到一个完整的线程池： 任务队列，存储需要处理的任务，
c语言编写线程池（附代码）
jiujiederoushan的博客
08-21 1636
简介：为了减少频繁创建和销毁线程带来的开销，提高程序的效率，可使用线程池处理并发失误，实时监控并控制线程数量，并使得任务先进先出有序处理。以下附上linux上C语言编写的线程池，并将测试数据打印到终端。 环境：redhat 设计简要：1、线程池分为管理者线程一个和工作线程若干。 2、管理者线程负责循环读取task链表头，若存在则判断是否有空闲线程且是否需要创...
c语言按给定成绩查询,C语言学生成绩管理系统（简易版）
weixin_42666036的博客
05-17 1908
#include#include#includeint readstudents(struct students stu[]); //读取学生信息int readsexcode(struct sexcode sex[]); //读取性别代码int readcollegecode(struct collegecode colle[]); //读取学院代码...
线程池开发流程（简易版）
weixin_40314888的博客
12-23 366
1.什么是线程池 线程池是一个抽象的概念，若干个线程组合到一起，形成线程池。 2.为什么需要线程池 多线程版服务器一个客户端就需要创建一个线程！若客户端太多，显然不太合适。 3.线程池使用场景 简单的说，如果一个应用需要频繁的创建和销毁线程，而任务执行的时间又非常短，这样线程创建和销毁的带来的开销就不容忽视，这时就需要线程池的帮忙了。当然，如果线程创建和销毁时间相比任务执行时间可以忽略不...
C语言 Linux Nginx 线程池
06-22
标题中的"C语言 Linux Nginx 线程池"涵盖了三个关键领域：C语言编程、Linux操作系统以及Nginx服务器。这些元素共同构成了一个高级话题，即如何在Linux环境中使用C语言来实现Nginx服务器的线程池功能。线程池是一种...
C语言实现简单线程池.zip
09-05
在本项目"简单线程池"中，我们将重点探讨如何用C语言在Linux环境下实现这样一个线程池系统，特别是关注其核心组件和设计原则。 首先，线程池的核心概念是线程复用，通过预先创建一组线程，可以避免频繁地创建和销毁...
基于C语言实现的线程池
02-18
使用C语言实现一个基本线程池，包含Linux下条件变量的使用、线程池创建与销毁等等
基于c语言高性能线程池.zip
06-15
C语言是一种广泛使用的编程语言，它具有高效、灵活、可移植性强等特点，被广泛应用于操作系统、嵌入式系统、数据库、编译器等领域的开发。C语言的基本语法包括变量、数据类型、运算符、控制结构（如if语句、循环语句...
C语言实现的线程池.zip
02-27
在C语言中实现线程池，通常会用到POSIX线程库（pthread），这是一个跨平台的线程API。 首先，我们需要理解线程的基本概念。线程是操作系统分配CPU时间的基本单位，一个进程中可以有多个线程，它们共享进程的资源，...
C 语言动态链表
qq_68495605的博客
07-25 1083
动态链表是通过结点（Node）的集合来非连续地存储数据，结点之间通过指针相互连接。动态链表本身就是一种动态分配内存的数据结构。每个结点都包含数据部分和指向下一个节点的指针。这种结构允许在运行时动态地添加、删除或修改结点，而不需要像数组那样担心容量问题。
thinkPHP开发的彩漂网站源码，含pc端和手机端
热门推荐
jiyc2008的博客
07-30 1万+
thinkPHP开发的菜票网站源码，含pc端和手机端
kechengsheji2021.zip
07-30
kechengsheji2021.zip
1cfa8b474c28bb76433ab12fc99ee5ad.jpeg
最新发布
07-30
1cfa8b474c28bb76433ab12fc99ee5ad.jpeg
TwineCompile571GetItSetup.7z
07-30
JomiTech TwineCompile 是一款集成在 C++Builder IDE 中的插件，旨在通过多种技术显著减少 C++ 编译、构建和生成的时间。以下是 TwineCompile 的一些关键能力和特点： 集成编译优化：TwineCompile 通过多线程、文件缓存和自动后台编译等技术，直接集成到 C++Builder IDE 中，优化编译过程。 编译器封装：它不是 C++ 编译器，而是将 Embarcadero 经典和 CLANG 编译器封装在一个构建系统中，优化文件和项目的构建方式。 IDE 支持：TwineCompile 通过 GetIt 包管理器提供，支持安装它的 IDE。对于旧版 IDE 或没有活跃更新订阅的 IDE，可以购买许可证以获得支持。 版本兼容性：TwineCompile 5.x 支持 C++Builder 10.2 至 C++Builder 12.0，而 TwineCompile 4.x 支持 C++Builder 5 至 C++Builder 10.1。
c语言简易版王者荣耀
06-21
C语言简易版的"王者荣耀"可能是指一个基于C语言基础概念的教学项目，旨在让学生通过编写简单的游戏逻辑来理解程序设计原理。这种简化版本可能包含以下几个部分： 1. **角色和单位**：玩家控制的角色可以是基础的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值