Linux线程池

最新推荐文章于 2024-09-22 16:31:47 发布
最新推荐文章于 2024-09-22 16:31:47 发布
阅读量136 收藏
点赞数
分类专栏： Linux系统编程 文章标签： 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43692030/article/details/100589731
版权

流程

初始化线程池
向线程池添加任务
销毁线程池

线程池初始化
初始化任务队列和工作线程组
将等候在条件变量（任务队列上有任务）上的一个线程唤醒并从该任务队列中取出第一个任务给该线程执行
等待任务队列中所有任务执行完毕

分文件

//task_queue.h

#ifndef __TASK_QUEUE_H__
#define __TASK_QUEUE_H__

#define WORK_THREAD_COUNT 6
 
typedef struct Task{
    void (*pfunc)();// 数据
    struct Task* next; // 指针域
}Task;
 
typedef struct{
    Task* head;
    Task* tail;
}TaskQueue;
 
void taskqueue_init(TaskQueue* queue);
void taskqueue_destory(TaskQueue* queue);
void taskqueue_push(TaskQueue* queue,Task* task);
void taskqueue_pop(TaskQueue* queue);
Task* taskqueue_front(TaskQueue* queue);
bool taskqueue_empty(TaskQueue* queue);
#endif //__TASK_QUEUE_H__ 

//task_queue.c

#include <pthread.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "task_queue.h"

void taskqueue_init(TaskQueue* queue){
    queue->head = queue->tail = NULL;
}
void taskqueue_destory(TaskQueue* queue){
    Task* p = queue->head;
    while(p != NULL){
        Task* q = p->next;
        free(p);
        p = q;
    }
    queue->head = queue->tail = NULL;
}
void taskqueue_push(TaskQueue* queue,Task* task){
    Task* copy = (Task*)malloc(sizeof(Task));
    memcpy(copy,task,sizeof(Task));
    if(NULL == queue->head){ // 入对第一个元素
        printf("入队第一个元素:%p\n",copy);
        queue->head = copy;
        queue->tail = copy;
    }else{ // 入队其他元素
        printf("入队元素:%p\n",copy);
        queue->tail->next = copy;
        queue->tail = copy;
    }
}
void taskqueue_pop(TaskQueue* queue){
    if(queue->head == NULL) return;
    Task* p = queue->head;
    printf("出队元素:%p\n",p);
    queue->head = p->next;
    free(p);
}
Task* taskqueue_front(TaskQueue* queue){
    return queue->head;
}
bool taskqueue_empty(TaskQueue* queue){
    return queue->head == NULL;
}


//thread_pool.h
#ifndef __THREAD_POOL_H__
#define __THREAD_POOL_H__
#include "task_queue.h"

#define WORK_THREAD_COUNT 6
typedef struct{
    pthread_t tids[WORK_THREAD_COUNT];///< 工作线程组
    TaskQueue queue;                  ///< 任务队列  
    pthread_mutex_t mutex;// 互斥量
    pthread_cond_t cond;// 条件变量
    bool running;
}ThreadPool;
 
void* func(void* arg);
bool threadpool_init(ThreadPool* pool);
bool threadpool_addtask(ThreadPool* pool,Task* task);
bool threadpool_destroy(ThreadPool* pool);
 
#endif  // __THREAD_POOL_H__

//thread_pool.c
#include <pthread.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "thread_pool.h" 
 
void* func(void* arg){
    ThreadPool* pool = (ThreadPool*)arg;
    pthread_mutex_lock(&pool->mutex);
    // 如果没有任务
    while(taskqueue_empty(&pool->queue)){
        printf("TID:%ld wait\n",pthread_self());
        pthread_cond_wait(&pool->cond,&pool->mutex);// 等待任务
        if(!pool->running){
            pthread_mutex_unlock(&pool->mutex);
            pthread_exit(0);
        }
    }
 
 
    // 取任务
    printf("TID:%ld get task\n",pthread_self());
    Task* task = taskqueue_front(&pool->queue);
    void(*pfunc)() = task->pfunc; 
    taskqueue_pop(&pool->queue);
    pthread_mutex_unlock(&pool->mutex);
 
    pfunc();// 做任务
}
 
/**
 * @brief 初始化线程池
 *
 * @param pool 线程池
 * @return 初始化结果
 */
bool threadpool_init(ThreadPool* pool){
    pool->running = true;
    pthread_mutex_init(&pool->mutex,NULL);
    pthread_cond_init(&pool->cond,NULL);
    // 初始化任务队列
    taskqueue_init(&pool->queue);
    // 初始化工作线程组
    int i;
    for(i=0;i<WORK_THREAD_COUNT;++i){
        pthread_create(pool->tids+i,NULL,func,pool);
    }
}
/**
 * @brief 向线程池添加任务
 *
 * @param pool 线程池
 * @param task 任务
 * @return 添加成功与否
 */
bool threadpool_addtask(ThreadPool* pool,Task* task){
    pthread_mutex_lock(&pool->mutex);
    taskqueue_push(&pool->queue,task);
    pthread_cond_signal(&pool->cond);
    pthread_mutex_unlock(&pool->mutex);
}
/**
 * @brief 销毁线程池
 *
 * @param pool 线程池
 * @return 销毁结果
 */
bool threadpool_destroy(ThreadPool* pool){
    pool->running = false;
    pthread_cond_broadcast(&pool->cond);
    // 销毁工作线程组
    int i;
    for(i=0;i<WORK_THREAD_COUNT;++i){
        pthread_join(pool->tids[i],NULL);
    }
    // 销毁任务队列
    taskqueue_destory(&pool->queue);
    pthread_mutex_destroy(&pool->mutex);
    pthread_cond_destroy(&pool->cond);
}

//main.c
#include <string.h>
#include "task_queue.h" 
#include "thread_pool.h" 

void test(){
    printf("TID：%lld do something\n",pthread_self());
	sleep(2);
}
int main(){
 
    ThreadPool pool;
    threadpool_init(&pool);
    Task t = {test,NULL};
    threadpool_addtask(&pool,&t);
    threadpool_addtask(&pool,&t);
    threadpool_addtask(&pool,&t);
    threadpool_addtask(&pool,&t);
 
    sleep(10);
    threadpool_destroy(&pool);
 
}

#include <pthread.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#define WORK_THREAD_COUNT 6
 
typedef struct Task{
    void (*pfunc)();// 数据
    struct Task* next; // 指针域
}Task;
 
typedef struct{
    Task* head;
    Task* tail;
}TaskQueue;
 
void taskqueue_init(TaskQueue* queue){
    queue->head = queue->tail = NULL;
}
void taskqueue_destory(TaskQueue* queue){
    Task* p = queue->head;
    while(p != NULL){
        Task* q = p->next;
        free(p);
        p = q;
    }
    queue->head = queue->tail = NULL;
}
void taskqueue_push(TaskQueue* queue,Task* task){
    Task* copy = (Task*)malloc(sizeof(Task));
    memcpy(copy,task,sizeof(Task));
    if(NULL == queue->head){ // 入对第一个元素
        printf("入队第一个元素:%p\n",copy);
        queue->head = copy;
        queue->tail = copy;
    }else{ // 入队其他元素
        printf("入队元素:%p\n",copy);
        queue->tail->next = copy;
        queue->tail = copy;
    }
}
void taskqueue_pop(TaskQueue* queue){
    if(queue->head == NULL) return;
    Task* p = queue->head;
    printf("出队元素:%p\n",p);
    queue->head = p->next;
    free(p);
}
Task* taskqueue_front(TaskQueue* queue){
    return queue->head;
}
bool taskqueue_empty(TaskQueue* queue){
    return queue->head == NULL;
}
 
 
/**
 * @brief 线程池
 */
typedef struct{
    pthread_t tids[WORK_THREAD_COUNT];///< 工作线程组
    TaskQueue queue;                  ///< 任务队列  
    pthread_mutex_t mutex;// 互斥量
    pthread_cond_t cond;// 条件变量
    bool running;
}ThreadPool;
 
void* func(void* arg){
    ThreadPool* pool = (ThreadPool*)arg;
    pthread_mutex_lock(&pool->mutex);
    // 如果没有任务
    while(taskqueue_empty(&pool->queue)){
        printf("TID:%ld wait\n",pthread_self());
        pthread_cond_wait(&pool->cond,&pool->mutex);// 等待任务
        if(!pool->running){
            pthread_mutex_unlock(&pool->mutex);
            pthread_exit(0);
        }
    }
 
 
    // 取任务
    printf("TID:%ld get task\n",pthread_self());
    Task* task = taskqueue_front(&pool->queue);
    void(*pfunc)() = task->pfunc; 
    taskqueue_pop(&pool->queue);
    pthread_mutex_unlock(&pool->mutex);
 
    pfunc();// 做任务
}
 
/**
 * @brief 初始化线程池
 *
 * @param pool 线程池
 * @return 初始化结果
 */
bool threadpool_init(ThreadPool* pool){
    pool->running = true;
    pthread_mutex_init(&pool->mutex,NULL);
    pthread_cond_init(&pool->cond,NULL);
    // 初始化任务队列
    taskqueue_init(&pool->queue);
    // 初始化工作线程组
    int i;
    for(i=0;i<WORK_THREAD_COUNT;++i){
        pthread_create(pool->tids+i,NULL,func,pool);
    }
}
/**
 * @brief 向线程池添加任务
 *
 * @param pool 线程池
 * @param task 任务
 * @return 添加成功与否
 */
bool threadpool_addtask(ThreadPool* pool,Task* task){
    pthread_mutex_lock(&pool->mutex);
    taskqueue_push(&pool->queue,task);
    pthread_cond_signal(&pool->cond);
    pthread_mutex_unlock(&pool->mutex);
}
/**
 * @brief 销毁线程池
 *
 * @param pool 线程池
 * @return 销毁结果
 */
bool threadpool_destroy(ThreadPool* pool){
    pool->running = false;
    pthread_cond_broadcast(&pool->cond);
    // 销毁工作线程组
    int i;
    for(i=0;i<WORK_THREAD_COUNT;++i){
        pthread_join(pool->tids[i],NULL);
    }
    // 销毁任务队列
    taskqueue_destory(&pool->queue);
    pthread_mutex_destroy(&pool->mutex);
    pthread_cond_destroy(&pool->cond);
}
 
void test(){
    printf("TID：%lld do something\n",pthread_self());
    sleep(2);
}
 
int main(){
 
    ThreadPool pool;
    threadpool_init(&pool);
    Task t = {test,NULL};
    threadpool_addtask(&pool,&t);
    threadpool_addtask(&pool,&t);
    threadpool_addtask(&pool,&t);
    threadpool_addtask(&pool,&t);
 
    sleep(10);
    threadpool_destroy(&pool);
 
}
三桂sg
关注
专栏目录
linux线程池，c语言实现
01-06
Linux线程池是一种高效的任务调度机制，它通过预先创建一组线程来处理任务，而不是每次需要执行任务时都创建新的线程。这种设计可以避免频繁地创建和销毁线程带来的开销，提高系统的响应速度和资源利用率。在C语言中...
Linux 线程池
09-03
【Linux 线程池】 线程池是操作系统或编程语言中的一种并发处理机制，它是一种高效的资源管理和任务调度方式。在Linux系统中，通过利用线程池，开发者可以有效地控制并发执行的任务数量，减少线程创建和销毁的开销...
从零开始学习Linux（14）---线程池
最新发布
lys20221113242的博客
09-22 761
如果锁不可用，线程就重复检查，直到锁可用为止。例如，假设线程A持有资源1并等待资源2，线程B持有资源2并等待资源1，这时线程A和线程B都会被阻塞，因为它们都在等待对方释放资源，而对方又不会释放资源，从而形成了一个循环等待链。例如，一个全局锁被用来保护一个共享资源和一个私有资源，如果一个线程在访问私有资源时持有全局锁，那么其他线程在访问共享资源时也将无法获取锁，从而导致死锁。例如，一个函数使用了一个外部锁来访问一个资源，如果该函数在执行过程中被另一个线程调用，而该线程也试图访问相同的资源，可能会导致死锁。
linux线程池
ffjffjffjffjffj的博客
12-12 378
include include include include include include include include include “threadpool.h”define DEFAULT_TIME 10 // 领导定时检查队列、线程状态的时间间隔define MIN_WAIT_TASK_NUM 10 // 队列中等待的任务数>这个值，便会增加线程define DEFAULT_THREA
Linux 线程池源码分析
11-12
非常详细的线程池函数接口分析，可以帮助初学者加深对线程池的理解，更好的去把线程池运用到实例中去，线程池就是多个线程组合在一起的集合，就像一家公司一样，由多个员工组成的一个集合，当有任务时， 这些线程就...
linux线程池代码（c++实现）
04-15
在Linux系统中，线程池是一种高效的多线程管理机制，它通过预先创建一组线程，然后将任务分配给这些线程执行，从而避免频繁地创建和销毁线程带来的开销。C++作为一门强大的系统编程语言，可以方便地实现线程池。下面...
linux系统线程池
gogo0707的博客
05-31 1051
本文简单介绍了线程池的概念和特点，对线程池的结构体和相关操作接口进行了设计，并提供了接口的具体实现，最后通过示例程序演示了线程池的运行过程。
Linux_线程池
lhn的博客
02-08 254
1、线程池 线程池是一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。 应用场景 需要大量的线程来完成任务，且完成任务的时间比较...
Linux之线程池
2303_77100822的博客
10-27 754
并且我们会发现这3个线程在处理时会呈现出一定的顺序性，因为主线程是每秒push一个任务，这3个线程只会有一个线程获取到该任务，其他线程都会在等待队列中进行等待，当该线程处理完任务后就会因为任务队列为空而排到等待队列的最后，当主线程再次push一个任务后会唤醒等待队列首部的一个线程，这个线程处理完任务后又会排到等待队列的最后，因此这3个线程在处理任务时会呈现出一定的顺序性。：指的就是一个类只能创建一个对象，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
Linux线程池实现：初学者指南
"这篇Linux线程池的源码示例主要涵盖了条件变量、互斥量、线程创建以及线程属性设置等多方面内容，适合初学者学习理解线程池的工作原理。" 在Linux系统中，线程池是一种管理线程资源的有效方式，它能够有效地提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值