备案控制台
开发者社区 开发与运维 文章 正文

C线程池

2022-05-02 107
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C线程池

1、准备工作

查看线程相关接口函数：


线程创建


int pthread_create(pthread_t thread, const pthread_attr_t attr,void (start_routine) (void ), void arg);


参数说明：


1.参数thread指向存放新创建线程的线程ID的地址


2.attr参数用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程。


3.start_routine是个函数指针，该函数返回类型是void，同时形式参数也是void。新创建的线程从start_routine函数的地址开始运行。该函数只有一个无类型指针参数arg.如果需要向start_routine函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。


返回值：


线程创建成功返回0，失败返回其他数值


线程退出


void pthread_exit(void *retval);


参数说明：


retval是一个无类型指针，进程中的其他线程可以通过调用pthread_join函数访问到这个指针。


线程等待


int pthread_join(pthread_t thread, void **retval);


参数说明：


调用这个函数的线程将一直阻塞，直到指定的线程调用pthread_exit. 如果对线程的返回值不感兴趣，可以把retval置为NULL。在这种情况下，调用pthread_join函数将等待指定的线程终止，但并不获得线程的终止状态。


线程取消


int pthread_cancel(pthread_t thread)；


参数说明：


thread为线程的id


设置线程的cancle信号


int pthread_setcancelstate(int state, int *oldstate) ；


PTHREAD_CANCEL_ENABLE：线程可取消。这是所有新线程的默认取消状态，包括初始线程。线程的可取消类型决定了可取消线程何时响应取消请求。


PTHREAD_CANCEL_DISABLE：线程不可取消。如果收到一个取消请求，它将被阻塞，直到可取消启用。


清理线程


void pthread_cleanup_push(void (*rtn)(void *), void *arg);


参数说明：


void(*rtn)(void *):线程清理函数

arg传递的参数


激活所有等待线程


pthread_cond_broadcast(pthread_cond_t *cond);

查看互斥锁相关接口函数：


创建互斥锁


int pthread_mutex_init(pthread_mutex_t restrict mutex,const pthread_mutexattr_t restrict attr);


参数说明：


1.在使用互斥锁前，需要定义互斥锁(全局变量)，定义互斥锁对象形式为：pthread_mutex_t lock;


2.mutex 是个指针，指向需要初始化的互斥锁；


3.参数attr指定了新建互斥锁的属性。如果参数attr为NULL，则使用默认的互斥锁属性，默认属性为快速互斥锁 。


销毁互斥锁


int pthread_mutex_destroy(pthread_mutex_t *mutex);


参数说明:


mutex为需要销毁的互斥锁；


上互斥锁


int pthread_mutex_lock(pthread_mutex_t *mutex);


参数说明:


mutex为需要加锁的互斥锁；


解互斥锁


int pthread_mutex_unlock(pthread_mutex_t *mute);


参数说明:


mutex为需要解锁的互斥锁；


查看条件变量相关接口函数：


条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。


初始化条件变量


int pthread_cond_init(pthread_cond_t cond, pthread_condattr_t cond_attr)；


参数说明:


1.cond为初始化的条件变量，是一个指向结构pthread_cond_t的指针；

2.cond_attr为cond_attr是一个指向结构pthread_condattr_t的指针；


销毁条件变量


int pthread_cond_destroy(pthread_cond_t *cond)；


参数说明:


cond为销毁的条件变量；


等待条件变量成立

int pthread_cond_wait(pthread_cond_t cond, pthread_mutex_t mutex)

激活一个等待该条件变量的线程

int pthread_cond_signal(pthread_cond_t *__cond);

存在多个等待线程时按入队顺序激活其中一个

2、创建数据结构

任务结构体


struct task
{
    void *(*task)(void *arg);    /* 任务需要执行的函数 */
    void *arg;                    /* 执行函数的参数 */
    struct task *next;            /* 下一个任务的地址 */
};


线程池结构体


typedef struct thread_pool
{
    pthread_mutex_t lock;
    pthread_cond_t  cond;
    struct task *task_list;    /*链表结构，线程池中所有等待任务*/
    pthread_t *tids;        /*存放线程id的指针*/
    unsigned waiting_tasks; /*当前等待的任务数*/
    unsigned active_threads;/*线程池中线程数目*/
    bool shutdown;            /*是否销毁线程池*/
}thread_pool;


3、线程池函数

初始化线程池


/*
 * @description: 初始化线程池
 * @param {thread_pool*} pool:线程池结构体指针 {unsigned int} max_thread_num: 创建几个线程
 * @return: false 失败 true 成功
 */
bool init_pool(thread_pool *pool, unsigned int threads_number)
{
    pthread_mutex_init(&pool->lock, NULL);    /*初始化线程锁*/
    pthread_cond_init(&pool->cond, NULL);    /*初始化条件变量*/
    pool->shutdown = false;                    
    pool->task_list = malloc(sizeof(struct task));
    pool->tids = malloc(sizeof(pthread_t) * MAX_ACTIVE_THREADS);
    if(pool->task_list == NULL || pool->tids == NULL)
    {
        perror("allocate memory error");
        return false;
    }
    pool->task_list->next = NULL;
    pool->waiting_tasks = 0;
    pool->active_threads = threads_number;
    int i;
    for(i=0; i<pool->active_threads; i++)
    {
        if(pthread_create(&((pool->tids)[i]), NULL,
                    routine, (void *)pool) != 0)
        {
            perror("create threads error");
            return false;
        }
    }
    return true;
}


向线程池添加任务


/*
 * @description: 向线程池添加任务
 * @param {thread_pool*} pool:线程池结构体指针 {void *(void *arg)} (*task): 线程的回调函数 {void *} arg: 传入的参数
 * @return: false 失败 true 成功
 */
bool add_task(thread_pool *pool,
            void *(*task)(void *arg), void *arg)
{
    struct task *new_task = malloc(sizeof(struct task));
    if(new_task == NULL)
    {
        perror("allocate memory error");
        return false;
    }
    new_task->task = task;
    new_task->arg = arg;
    new_task->next = NULL;
    pthread_mutex_lock(&pool->lock);
    if(pool->waiting_tasks >= MAX_WAITING_TASKS)
    {
        pthread_mutex_unlock(&pool->lock);
        fprintf(stderr, "too many tasks.\n");
        free(new_task);
        return false;
    }
    struct task *tmp = pool->task_list;
    while(tmp->next != NULL)
        tmp = tmp->next;
    tmp->next = new_task;
    pool->waiting_tasks++;
    pthread_mutex_unlock(&pool->lock);
    pthread_cond_signal(&pool->cond);
    return true;
}


向线程池添加线程


/*
 * @description: 向线程池添加线程
 * @param {thread_pool*} pool:线程池结构体指针 {unsigned int} additional_threads: 添加的线程数
 * @return: 返回成功的线程数
 */
int add_thread(thread_pool *pool, unsigned int additional_threads)
{
    if(additional_threads == 0)
        return 0;
    unsigned int total_threads =
             pool->active_threads + additional_threads;
    int i, actual_increment = 0;
    for(i = pool->active_threads;
        i < total_threads && i < MAX_ACTIVE_THREADS;
        i++)
    {
        if(pthread_create(&((pool->tids)[i]),
                NULL, routine, (void *)pool) != 0)
        {
            perror("add threads error");
            if(actual_increment == 0)
                return -1;
            break;
        }
        actual_increment++; 
    }
    pool->active_threads += actual_increment;
    return actual_increment;
}


线程的回调处理函数


/*
 * @description: 回调处理函数
 * @param  {void *} arg: 传入的参数
 * @return: 无
 */
void handler(void *arg)
{
    pthread_mutex_unlock((pthread_mutex_t *)arg);
}
/*
 * @description: 线程的回调处理函数
 * @param  {void *} arg: 传入的参数
 * @return: 无
 */
void *routine(void *arg)
{
    thread_pool *pool = (thread_pool *)arg;
    struct task *p;
    while(1)
    {
        pthread_cleanup_push(handler, (void *)&pool->lock);
        pthread_mutex_lock(&pool->lock);
        while(pool->waiting_tasks == 0 && !pool->shutdown)
        {
            pthread_cond_wait(&pool->cond, &pool->lock);
        }
        if(pool->waiting_tasks == 0 && pool->shutdown == true)
        {
            pthread_mutex_unlock(&pool->lock);
            pthread_exit(NULL);
        }
        p = pool->task_list->next;
        pool->task_list->next = p->next;
        pool->waiting_tasks--;
        pthread_mutex_unlock(&pool->lock);
        pthread_cleanup_pop(0);
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
        (p->task)(p->arg);
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
        free(p);
    }
    pthread_exit(NULL);
}


线程池里取消线程


/*
 * @description: 线程池里取消线程
 * @param {thread_pool*} pool:线程池结构体指针 {nsigned int} removing_threads: 取消的线程数
 * @return: 失败返回-1
 */
int remove_thread(thread_pool *pool, unsigned int removing_threads)
{
    if(removing_threads == 0)
        return pool->active_threads;
    int remain_threads = pool->active_threads - removing_threads;
    remain_threads = remain_threads>0 ? remain_threads:1;
    int i;
    for(i=pool->active_threads-1; i>remain_threads-1; i--)
    {
        errno = pthread_cancel(pool->tids[i]);
        if(errno != 0)
            break;
    }
    if(i == pool->active_threads-1)
        return -1;
    else
    {
        pool->active_threads = i+1;
        return i+1;
    }
}

销毁线程池


/*
 * @description: 销毁线程池
 * @param {thread_pool*} pool:线程池结构体指针
 * @return: 成功返回true
 */
bool destroy_pool(thread_pool *pool)
{
    pool->shutdown = true;
    pthread_cond_broadcast(&pool->cond);
    int i;
    for(i=0; i<pool->active_threads; i++)
    {
        errno = pthread_join(pool->tids[i], NULL);
        if(errno != 0)
        {
            printf("join tids[%d] error: %s\n",
                    i, strerror(errno));
        }
        else
            printf("[%u] is joined\n", (unsigned)pool->tids[i]);
    }
    free(pool->task_list);
    free(pool->tids);
    free(pool);
    return true;
}


4、完整代码

由于篇幅较长就不贴出来 代码放百度云，需要的在微信公众号回复【线程】即可获取链接下载


使用：Linux下进入文件夹执行make生成可执行文件test执行即可


5.png


如果你觉得文章还不错，可以给个"三连"


我是加班猿，我们下期见

文章标签：
Java
Linux
hackett
目录
相关文章
整日摸鱼的小黑猫
|
1月前
|
NoSQL Java 应用服务中间件
线程池的实现
线程池的实现
整日摸鱼的小黑猫
25 0
₍ᐢ..ᐢ₎王
|
1月前
|
缓存 Java
线程池
线程池
₍ᐢ..ᐢ₎王
36 0
橙子先生
|
1月前
|
存储 Java 调度
浅谈线程池
浅谈线程池
橙子先生
23 1
yuxialuozi
|
10月前
|
缓存 Java
线程池简单总结
线程池简单总结
yuxialuozi
70 0
Hello，C++！
|
1月前
|
Java C++
c++简单线程池实现
c++简单线程池实现
Hello，C++！
33 0
王有志
|
存储 Java 测试技术
13.一文彻底了解线程池
大家好，我是王有志。线程池是Java面试中必问的八股文，涉及到非常多的问题，今天我们就通过一篇文章，来彻底搞懂Java面试中关于线程池的问题。
王有志
372 2
13.一文彻底了解线程池
霸总爱吃鱿鱼虾
|
10月前
|
监控 Java
线程池的讲解和实现
线程池的讲解和实现
霸总爱吃鱿鱼虾
63 0
哔卟哔卟_:)
|
11月前
|
缓存 Java 调度
线程池的介绍
线程池的介绍
哔卟哔卟_:)
65 0
GG_Bond19
|
11月前
|
存储 缓存 Java
理解与实现线程池
理解与实现线程池
GG_Bond19
113 0
运维开发故事
|
Java
KeyAffinityExecutor 线程池
KeyAffinityExecutor 线程池
运维开发故事
166 0