线程池技术

已于 2022-05-19 01:22:07 修改
阅读量503 收藏 1
点赞数
分类专栏： 笔记 文章标签： java 开发语言
于 2022-05-18 00:13:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53812805/article/details/124831589
版权

目录

一、线程池概述

1、为什么要使用线程池？

2、线程池的核心

二、线程池的实现

1、线程池实现的一般步骤：

（1）完成任务队列结构体、线程池结构体

（2）初始化线程池：将线程池内部变量注意初始化；

（3）写线程函数（固定格式）：先加互斥锁；将任务队列中任务取出执行；没有任务，就等待队列不为空；取出任务后，执行任务函数；队列头指针加1，任务数减1；然后解锁；

（4）写任务进队列函数（重点）：先加互斥锁；等待队列不满（链式队列不存在）；将任务放入人户队列中（任务包含：任务函数、函数参数）；队列尾指针加1，任务数加1；然后解锁；

（5）写任务函数功能（重点：可以调用功能不同的函数）：任务函数可以功能各不相同（函数名不同），但是参数与结构必须相同；

（6）销毁线程池（固定格式）：等待队列为空；唤醒所以线程；释放所有线程；销毁互斥锁和条件变量；将队列置空；释放pool;

2、代码实现

三、可伸缩线程池的实现

一、线程池概述

1、为什么要使用线程池？

一个进程所支持的线程是有限的（受限）；

线程的创建与销毁是有一定的开销的（当线程数目多时）；

（内存池是解决频繁malloc产生的开销问题；对象池是解决对象频繁分配所带来的开销问题）

2、线程池的核心

任务队列：用来存放客户端所请求的服务（所要完成的功能函数）

线程池：用于存放线程（还包含线程数量，任务队列头/尾指针，任务队列大小，互斥锁，条件变量，线程销毁标志位等）

当任务队列为空时，线程池里的线程阻塞等待；

任务队列不为空时，线程池里的线程处理任务；

任务队列为满时，不能再次新增任务；

二、线程池的实现

1、线程池实现的一般步骤：

（1）完成任务队列结构体、线程池结构体

最完整版：

struct job{
    void *(*func)(void *arg);    //队列中的函数
    void *arg;                  //功能函数的参数
    struct job *next;             // 指向下一个节点
};

struct threadpool{
    int thread_num;             //线程的个数
    pthread_t *ids;              //线程的id

    int queue_max_num;           //队列的最大容量
    int queue_cur_num;          //队列正在执行的个数
    struct job *head;           //队列的头
    struct job *tail;           //队列的尾

    pthread_mutex_t mutex;       //锁队列的增与减
    pthread_cond_t not_empty;     //非空
    pthread_cond_t not_full;       //非满
    pthread_cond_t queue_empty;   //队列为空

    
};

注意：队列函数可以按要求更改；线程池结构体（队列非满（not_full）可以省略（链式队列无满情况），队列为空（queue_empty）也可以去掉，队列最大容量（queue_max_num）也可以去掉，链式队列无最大容量）也可更改；

（2）初始化线程池：将线程池内部变量注意初始化；

（3）写线程函数（固定格式）：先加互斥锁；将任务队列中任务取出执行；没有任务，就等待队列不为空；取出任务后，执行任务函数；队列头指针加1，任务数减1；然后解锁；

（4）写任务进队列函数（重点）：先加互斥锁；等待队列不满（链式队列不存在）；将任务放入人户队列中（任务包含：任务函数、函数参数）；队列尾指针加1，任务数加1；然后解锁；

（5）写任务函数功能（重点：可以调用功能不同的函数）：任务函数可以功能各不相同（函数名不同），但是参数与结构必须相同；

（6）销毁线程池（固定格式）：等待队列为空；唤醒所以线程；释放所有线程；销毁互斥锁和条件变量；将队列置空；释放pool;

2、代码实现

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

struct job{
    void *(*func)(void *arg);    //队列中的函数
    void *arg;                  //功能函数的参数
    struct job *next;             // 指向下一个节点
};

struct threadpool{
    int thread_num;             //线程的个数
    pthread_t *ids;              //线程的id

    int queue_max_num;           //队列的最大容量
    int queue_cur_num;          //队列正在执行的个数
    struct job *head;           //队列的头
    struct job *tail;           //队列的尾

    pthread_mutex_t mutex;       //锁队列的增与减
    pthread_cond_t not_empty;     //非空
    pthread_cond_t not_full;       //非满
    pthread_cond_t queue_empty;   //队列为空

    
};

void *thread_function(void *arg)   //线程函数
{
    struct threadpool *pool = (struct threadpool *)arg;
    struct job *fjob = NULL;

    while (1)
    {
        pthread_mutex_lock(&(pool->mutex));
        if (pool->queue_cur_num == 0)
        {
            pthread_cond_wait(&(pool->not_empty), &(pool->mutex));
        }

        fjob = pool->head;
        pool->queue_cur_num--;

        if (pool->queue_cur_num != pool->queue_max_num)
        {
            pthread_cond_signal(&(pool->not_full));
        }
        

        if (pool->queue_cur_num == 0)
        {
            pool->head = pool->tail = NULL;
            pthread_cond_signal(&(pool->queue_empty));
        }
        else
        {
            pool->head = pool->head->next;
        }

        pthread_mutex_unlock(&(pool->mutex));

        (*(fjob->func))(fjob->arg);
        free(fjob);
        fjob = NULL;
        
    }
    
}

struct threadpool *threadpool_init(int thread_num, int queue_max_num)   //初始化线程池
{

    struct threadpool *pool = (struct threadpool *)malloc(sizeof(struct threadpool));

    pool->thread_num = thread_num;
    pool->ids = (pthread_t *)malloc(sizeof(pthread_t)*thread_num);
    pool->queue_max_num = queue_max_num;
    pool->queue_cur_num = 0;
    pool->head = NULL;
    pool->tail = NULL;

    pthread_mutex_init(&(pool->mutex), NULL);
    pthread_cond_init(&(pool->queue_empty), NULL);
    pthread_cond_init(&(pool->not_empty), NULL);
    pthread_cond_init(&(pool->not_full), NULL);

    for (int i = 0; i < pool->thread_num; i++)
    {
        pthread_create(&(pool->ids[i]), NULL, (void *)thread_function, (void *)pool);
    }
    
    return pool;
}

void *work_function(void *arg)   //队列函数
{
    char *p = (char *)arg;
    printf("hello word!%s\n", p);
    printf("welcome jestc!%s\n", p);
    sleep(1);
}

void threadpool_add_job(struct threadpool *pool, void *(*work_function)(void *), void *arg)   //向队列中添加任务节点
{
    pthread_mutex_lock(&(pool->mutex));
    while (pool->queue_cur_num == pool->queue_max_num)
    {
        pthread_cond_wait(&(pool->not_full), &(pool->mutex));
    }

    struct job * fjob = (struct job *)malloc(sizeof(struct job));
    fjob->next = NULL;
    fjob->func = work_function;
    fjob->arg = arg;

    if (pool->head == NULL)
    {
        pool->head = pool->tail = fjob;
        pthread_cond_signal(&(pool->not_empty));
    }
    else
    {
        pool->tail->next = fjob;
        pool->tail = fjob;
    }

    pool->queue_cur_num++;

    pthread_mutex_unlock(&(pool->mutex));
    
}

void  threadpool_destory(struct threadpool *pool)    //释放线程池
{
    pthread_mutex_lock(&(pool->mutex));

    while (1)
    {
        pthread_cond_wait(&(pool->queue_empty), &(pool->mutex));
    }

    pthread_mutex_unlock(&(pool->mutex));

    pthread_cond_signal(&(pool->not_empty));   //唤醒线程池
    pthread_cond_signal(&(pool->not_full));

    for (int  i = 0; i < pool->thread_num; i++)
    {
        pthread_join(pool->ids[i], NULL);
    }
    
    pthread_mutex_destroy(&(pool->mutex));
    pthread_cond_destroy(&(pool->not_empty));
    pthread_cond_destroy(&(pool->not_full));
    pthread_cond_destroy(&(pool->queue_empty));

    free(pool->ids);

    struct job *temp = NULL;
    while (pool->head != NULL)
    {
        temp = pool->head;
        pool->head = temp->next;
        free(temp);
    }

    free(pool);
    
}


int main(int argc, char *argv[])
{
    struct threadpool * pool = threadpool_init(5, 100);    //创建线程池

    threadpool_add_job(pool, (void *)work_function, "1");   //向队列中添加任务节点
    threadpool_add_job(pool, (void *)work_function, "2");
    threadpool_add_job(pool, (void *)work_function, "3");
    threadpool_add_job(pool, (void *)work_function, "4");
    threadpool_add_job(pool, (void *)work_function, "5");
    threadpool_add_job(pool, (void *)work_function, "6");
    threadpool_add_job(pool, (void *)work_function, "7");
    threadpool_add_job(pool, (void *)work_function, "8");
    threadpool_add_job(pool, (void *)work_function, "9");
    threadpool_add_job(pool, (void *)work_function, "10");

    threadpool_add_job(pool, (void *)work_function, "11");   //向队列中添加任务节点
    threadpool_add_job(pool, (void *)work_function, "12");
    threadpool_add_job(pool, (void *)work_function, "13");
    threadpool_add_job(pool, (void *)work_function, "14");
    threadpool_add_job(pool, (void *)work_function, "15");
    threadpool_add_job(pool, (void *)work_function, "16");
    threadpool_add_job(pool, (void *)work_function, "17");
    threadpool_add_job(pool, (void *)work_function, "18");
    threadpool_add_job(pool, (void *)work_function, "19");
    threadpool_add_job(pool, (void *)work_function, "20");

    threadpool_destory(pool);

    return 0;
}

注意：任务函数金队列和任务函数尤为重要；

三、可伸缩线程池的实现

充满热情的常春藤叶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程池技术详解
06-14
如何利用已有对象来服务就是一个需要解决的关键问题，其实这就是一些"池化资源"技术产生的原因。 2.简介 线程池（thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而...
线程池技术介绍
mlsama的博客
11-02 1855
1 概述          创建一个线程非常简便,但是如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。        为了解决这样的问题,Java提出了线程池这个解决方法.所谓的线程池其实就是一个存放线程的容器.调用线程池去执行并发任务时,从线程池中取出线程去执行任务,每个线程 执行完任务，并不...
多线程与线程池技术详解（图书配套）
07-01
本套视频为同名图书的配套视频，图书预计在2021.4上市
多线程与线程池技术详解
06-12
在当前的Java面试和后台开发中，多线程与线程池技术越来越重要。毫不夸张的说，如何你想进入任何一家好的网络公司并能够长足发展，多线程与线程池技术是必须要掌握的技能！
线程池技术在并发服务器中的应用
08-23
线程池技术在并发服务器中的应用
【Java线程池快速学习教程】
weixin_30569033的博客
09-17 63
1. Java线程池 　　线程池：顾名思义，用一个池子装载多个线程，使用池子去管理多个线程。 　　问题来源：应用大量通过new Thread()方法创建执行时间短的线程，较大的消耗系统资源并且系统的响应速度变慢。【在一个什么程度上能够判断启用线程池对系统的资源消耗比启动定量的new Thread()资源消耗低？这个怎么测试？】【用户体验卡顿？慢？观察CPU百分比？】 　　解决办法：使用...
线程池设计及注意问题
tianxiaogang12的专栏
10-15 2306
<br /><br />一般一个简单线程池至少包含下列组成部分。线程池管理器（ThreadPoolManager）:用于创建并管理线程池工作线程（WorkThread）: 线程池中线程任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行。任务队列:用于存放没有处理的任务。提供一种缓冲机制<br /> <br /><br />关于高级线程池的探讨<br /> <br />简单线程池存在一些问题，比如如果有大量的客户要求服务器为其服务，但由于线程池的工作线程是有限的，服务器只能为部分客户服务
Linux C 线程池
花季;雨季的博客
12-01 211
1.线程池基本原理 在传统服务器结构中, 常是 有一个总的 监听线程监听有没有新的用户连接服务器, 每当有一个新的 用户进入, 服务器就开启一个新的线程用户处理这 个用户的数据包。这个线程只服务于这个用户 , 当 用户与服务器端关闭连接以后, 服务器端销毁这个线程。然而频繁地开辟与销毁线程极大地占用了系统的资源。而且在大量用户的情况下, 系统为了开辟和销毁线程将浪费大量
线程池相关技术
Habby的专栏
07-15 587
shutdown()和shutdownNow()区别：http://justsee.iteye.com/blog/999189
java线程池技术原理
最新发布
05-20
Java线程池是一种用于管理多个线程的机制，它可以帮助我们优化应用程序的性能，避免由于线程的创建和销毁带来的开销。 Java线程池技术的原理如下： 1. 线程池初始化：线程池初始化时会创建一定数量的线程，这些线程会一直存在，并且不断地等待任务的到来。 2. 任务提交：当有任务需要执行时，我们可以向线程池提交任务。 3. 任务队列：线程池会维护一个任务队列，任务会先进入队列中等待执行。 4. 任务执行：线程池中的线程会不断地从任务队列中取出任务，并执行任务。 5. 线程复用：当一个线程执行完任务后，它并不会立即销毁，而是会继续等待新的任务到来，这样就避免了线程频繁地创建和销毁带来的开销。 6. 线程数量控制：线程池可以根据需要动态地调整线程数量，以在不同的负载下保持最佳性能。 7. 线程超时处理：线程池还可以设置线程的超时时间，当一个线程长时间没有执行任务时，它会被回收，以释放资源。 总之，Java线程池技术通过合理地维护线程池中的线程数量和任务队列，可以有效地避免线程频繁创建和销毁带来的性能问题，提高应用程序的性能和稳定性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值