浅谈【多线程与并发】之线程池

最新推荐文章于 2024-08-12 21:25:19 发布
最新推荐文章于 2024-08-12 21:25:19 发布
阅读量756 收藏 19
点赞数 11
分类专栏： 多线程与并发 文章标签： linux 开发语言 ubuntu c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67526434/article/details/141021614
版权

目录

1、多线程/并发处理形式

1.1线程池的工作原理

2、项目-线程池

2.1数据说明

2.2PTP线程池的API

2.2.1 初始化线程池

2.2.2为线程池增加任务

2.2.3销毁线程池

谢谢帅气美丽且优秀的你看完我的文章还要点赞、收藏加关注

没错，说的就是你，不用再怀疑！！！

希望我的文章内容能对你有帮助，一起努力吧！！！

该篇文章主要内容为设计实现一个线程池库，适用于线程并发执行任务

1、多线程/并发处理形式

线程池：是一种多线程/并发处理形式，他运行将任务添加队列里面，并在创建线程之后自动启动这些任 务。

线程池的作用：

  • 复用线程：减少线程的创建和销毁的开销。
    • 通过预先创建一定数量的线程并且存储在线程池中，可以避免频繁的创建和销毁操作。
  • 有效的控制线程的数量：方便的进行线程管理，可以控制同时运行的线程数量，防止线程过多导致 资源耗尽的问题。
  • 提高系统响应速度：当有新任务的时候，不需要创建线程，立马执行。

1.1线程池的工作原理

  • 在应用程序启动时候，创建一定数量的线程存储在线程池中。
    • 这些线程是待命状态（休眠状态）
  • 当需要执行任务的时候，从线程池中抓取一个空闲的线程，将任务分配给该线程去执行
    • 当有任务存在，就随机唤醒一个线程去执行
  • 任务执行完毕之后，线程返回到线程池中，继续待命（休眠）。
    • 任务结束，就休眠

2、项目-线程池

需求：设计一个线程池库，适用于线程并发执行任务，可以动态规划线程池内线程数目。基于 POSIX Thread 进行开发

项目名： POSIX-Thread-Pool简称PTP

2.1数据说明

任务类型： task_t

  • task_point ：任务函数指针，即用户自定义的任务函数（线程需要去执行的任务函数指针）
  • args ：线程在执行 task_point 指向的任务的时候，需要使用到的参数
  • next ：指向下一个任务结点

线程池类型： ptp_t

  • thread_count ：线程池中最大线程数量，即能够支持的最高并发数目
  • thread_status ：线程池当前状态，启动或停止状态
  • thread_id ：线程池中服役线程集合
  • thread_mutex ：线程池中线程的共享互斥锁
  • thread_cond ：线程池中线程共享的条件变量
  • thread_tasks ：线程池中线程所需要执行的任务链表
  • loop_task ：线程池中轮询线程池任务链表的线程

2.2PTP线程池的API

2.2.1 初始化线程池

2.2.2为线程池增加任务

2.2.3销毁线程池

main.cpp

#include <iostream>
#include "POSIX_Thread_Pool.h"

/**
 * @brief 任务函数
 * @param 参数
 * 
 */

void task(void *args)
{

    std::cout << "嘿嘿<" << pthread_self() << ">我开始执行任务了!!!" << std::endl;

    // 模拟执行任务的过程
    sleep(5);

    std::cout << "嘿嘿<" << pthread_self() << ">我执行完毕!!!" << std::endl;
}

int main()
{
    // 创建并启动一个线程池
    ptp_t * thread_pool = ptp_init(10);

    // 为其添加任务
    for(int i = 0;i < 20;i++)
    {
        ptp_add_task(thread_pool,task,NULL);
    }

    while(ptp_task_is_null(thread_pool));

    ptp_destroy(thread_pool);
    return 0;
}

​​​​​​​

POSIX_Thread_Pool.h

#ifndef __POSIX_THREAD_POOL_H__
#define __POSIX_THREAD_POOL_H__

#include <pthread.h>
#include <unistd.h>


typedef void (*task_point_t)(void *);

/*
    - `task_point`：任务函数指针，即用户自定义的任务函数（线程需要去执行的任务函数指针）
    - `args`：线程在执行`task_point`指向的任务的时候，需要使用到的参数
    - `next`：指向下一个任务结点
*/
// 任务结构类型
typedef struct tasks
{
	// 任务指针
    task_point_t task_point;
    /*
    	// 任务函数需要符合这个规则
    	void task(void *data)
    	{
    		// 需要执行的任务
    	}
    */
    
    // 任务执行所需要参数
    void *args;
    
    // 下一个任务
    struct tasks *next;
}task_t;


/*
    - `thread_count`：线程池中最大线程数量，即能够支持的最高并发数目
    - `thread_status`：线程池当前状态，启动或停止状态
    - `thread_id`：线程池中服役线程集合
    - `thread_mutex`：线程池中线程的共享互斥锁
    - `thread_cond`：线程池中线程共享的条件变量
    - `thread_tasks`：线程池中线程所需要执行的任务链表
*/
typedef struct posix_thread_pool
{
	// 线程的个数
    int  			 thread_count; 
    
    // 线程池状态
    bool			 thread_status;
    
    // 线程集合
    pthread_t		*thread_id;
    
    // 线程池中线程共享的互斥锁
    pthread_mutex_t  thread_mutex;
    
    // 线程池中线程共享的条件变量，即通知
    pthread_cond_t   thread_cond;
    
    // 线程任务链表
    task_t			*thread_tasks;
    
    // 轮询任务的线程
    pthread_t        loop_task;
    /*
    	最大线程的数目：表示可以支持线程并发的最大线程数
    	当前服役的线程数目：表示当前能够并发的线程数量
    	当前休眠的线程数目：表示当前正在待命且可以执行任务的线程数量。
    	...
    */    
}ptp_t;

/**
 * @brief 创建并初始化一个POSIX线程池
 * @param count 设置线程池的最大并发线程数量
 * @return 成功返回创建并初始化完毕的线程池指针，失败返回NULL
*/
ptp_t *ptp_init(int count);


/**
 * @brief 往指定的线程池中增加任务
 * @param thread_pool 需要增加任务的线程池
 * @param task 增加的任务指针
 * @param args 任务执行所需要的参数
 * @return NULL
 */
void ptp_add_task(ptp_t *thread_pool,task_point_t task,void *args);

/**
 * @brief 销毁一个已经存在的线程池
 * @param thread_pool 需要销毁的线程池指针引用
 */
void ptp_destroy(ptp_t *&thread_pool);

/**
 * @brief 判断任务是否为空
 * @param thread_pool 需要判断任务的线程池指针
 * @return 成功返回true，失败返回false
 */
bool  ptp_task_is_null(ptp_t *thread_pool);

#endif //__POSIX_THREAD_POOL_H__

POSIX_Thread_Pool.cpp

#include "POSIX_Thread_Pool.h"


/**
 * @brief 任务线程函数
 * @param args 表示线程执行任务所需要参数
 * @return NULL
 */
void *ptp_start_routine(void *args);

/**
 * @brief 轮询任务链表，如果任务链表不为空，就持续线程
 * @param thread_pool 需要轮询任务链表的线程池 
 * */
void *loop_task(void * args)
{
    // 先获取线程池指针
    ptp_t *thread_pool = (ptp_t*)args;

    while(thread_pool->thread_status)
    {
        pthread_mutex_lock(&thread_pool->thread_mutex);
        if(thread_pool->thread_tasks)
            pthread_cond_signal(&thread_pool->thread_cond);
        pthread_mutex_unlock(&thread_pool->thread_mutex);
        usleep(1000);
    }
    return NULL;
}

/**
 * @brief 创建并初始化一个POSIX线程池
 * @param count 设置线程池的最大并发线程数量
 * @return 成功返回创建并初始化完毕的线程池指针，失败返回NULL
*/
ptp_t *ptp_init(int count)
{
    // 申请一个线程池空间
    ptp_t *thread_pool = new ptp_t;

    /*
        初始化成员变量
            1、线程池的线程个数
            2、通过线程池中线程个数，为线程集合申请线程ID集合的空间
            3、设置线程池状态
            4、任务列表初始化
            5、初始化线程互斥锁
            6、初始化条件变量
            7、创建线程池中的线程
            8、创建任务轮询线程
    */
    thread_pool->thread_count  = count;
    thread_pool->thread_id     = new pthread_t[count];
    thread_pool->thread_status = true;
    thread_pool->thread_tasks  = NULL;
    pthread_mutex_init(&thread_pool->thread_mutex,NULL);
    pthread_cond_init(&thread_pool->thread_cond,NULL);

    /*创建线程*/
    for(int i = 0;i < count;i++)
    {
        // 判断线程是否创建失败
        if(pthread_create((thread_pool->thread_id+i),NULL,ptp_start_routine,thread_pool) != 0)
        {
            i--;
            continue; // 重新创建线程
        }
    }

    while(pthread_create(&thread_pool->loop_task,NULL,loop_task,thread_pool)!=0);

    // 返回创建好的线程池指针
    return thread_pool;
}

/**
 * @brief 任务线程函数
 * @param args 表示线程执行任务所需要参数
 * @return NULL
 */
void *ptp_start_routine(void *args)
{
    // 先获取线程池指针
    ptp_t *thread_pool = (ptp_t*)args;

    /*
        循环：循环执行任务和等待
            阻塞：休眠等待条件变化唤醒线程去执行任务，执行完之后重新休眠
    */
   do
   {
        /*上锁：创建临界区*/
        pthread_mutex_lock(&thread_pool->thread_mutex);

        /*进入休眠：等待被条件唤醒*/
        pthread_cond_wait(&thread_pool->thread_cond,&thread_pool->thread_mutex);

        /*
            被唤醒之后要做的事情
                1、从线程池的任务链表摘取一个任务
                2、去执行这个任务
                3、执行完毕之后重新休眠
        */
        task_t *task = NULL;

        // 没有任务的情况
        if(thread_pool->thread_tasks == NULL)
        {
            pthread_mutex_unlock(&thread_pool->thread_mutex);
            goto cont; // 继续休眠
        }

        // 摘取任务
        task                      = thread_pool->thread_tasks;
        thread_pool->thread_tasks = thread_pool->thread_tasks->next;

        pthread_mutex_unlock(&thread_pool->thread_mutex);

        /*执行任务*/
        (task->task_point)(task->args); // 等价 task_point(task->args);

        /*执行完毕之后：销毁任务，释放空间*/
        task->next = NULL;
        delete task;
cont:
        task = NULL;

   } while (thread_pool->thread_status);
   
   return NULL;
}

/**
 * @brief 往指定的线程池中增加任务
 * @param thread_pool 需要增加任务的线程池
 * @param task 增加的任务指针
 * @param args 任务执行所需要的参数
 * @return NULL
 */
void ptp_add_task(ptp_t *thread_pool,task_point_t task,void *args)
{
    /*
        任务是存储在一个任务结点中的
            1、申请一个任务结点空间
    */
   task_t *task_node = new task_t;

   /*2、初始化任务结点*/
   task_node->args = args;
   task_node->task_point = task;
   task_node->next = NULL;

    /*
        添加到线程池中
            线程池中的任务链表是线程共享的（共享资源）
                需要用到互斥锁
    */
    pthread_mutex_lock(&thread_pool->thread_mutex);

    // 判断任务链表中是否为空
    if(thread_pool->thread_tasks == NULL)
        thread_pool->thread_tasks = task_node;
    else
    {
        /* 找任务链表的尾结点：进行尾插 */
        task_t *task_temp = thread_pool->thread_tasks;
        while(task_temp->next)
            task_temp = task_temp->next;
        
        task_temp->next = task_node;
    }

    /* 添加完成任务之后：任务区有任务了，就需要唤醒线程去执行任务*/
    pthread_cond_signal(&thread_pool->thread_cond);

    pthread_mutex_unlock(&thread_pool->thread_mutex);
}

/**
 * @brief 销毁一个已经存在的线程池
 * @param thread_pool 需要销毁的线程池指针引用
 */
void ptp_destroy(ptp_t *&thread_pool)
{
    /*关闭线程池*/
    pthread_mutex_lock(&thread_pool->thread_mutex);
    thread_pool->thread_status = false;
    pthread_mutex_unlock(&thread_pool->thread_mutex);

    /*任务轮询线程回收*/
    pthread_join(thread_pool->loop_task,NULL);

    /*唤醒所有的线程*/
    pthread_cond_broadcast(&thread_pool->thread_cond);

    /*等待线程结束*/
    for(int i = 0;i < thread_pool->thread_count;i++)
        pthread_join(thread_pool->thread_id[i],NULL);
    
    /*销毁任务链表*/
    task_t *task = thread_pool->thread_tasks;
    while(task)
    {
        thread_pool->thread_tasks = thread_pool->thread_tasks->next;

        task->next = NULL;
        delete task;
        task = thread_pool->thread_tasks;
    }
    thread_pool->thread_tasks = NULL;


    /*销毁线程ID数组空间*/
    delete []thread_pool->thread_id;
    thread_pool->thread_id = NULL;

    /*销毁条件变量和互斥锁*/
    pthread_mutex_destroy(&thread_pool->thread_mutex);
    pthread_cond_destroy(&thread_pool->thread_cond);

    /*将线程池释放，并置空*/
    delete thread_pool;
    thread_pool = NULL;
}

/**
 * @brief 判断任务是否为空
 * @param thread_pool 需要判断任务的线程池指针
 * @return 成功返回true，失败返回false
 */
bool  ptp_task_is_null(ptp_t *thread_pool)
{
    if(thread_pool == NULL)
        return false;
    else if(thread_pool->thread_tasks == NULL)
        return false;
    else
        return true;
}

超级飞侠12138
关注
  • 11
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java多线程】JUC之线程池(二)再次邂逅线程池ThreadPoolExecutor的原理
墩墩分墩
08-23 252
**一个线程池包括以下四个基本组成部分：** 1. 线程工厂（ThreadFactory）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务； 2. 工作线程（Worker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务； 3. 任务接口（Runnable）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等； 4. 任务队列（workQueue）：用于存放待执行的任务。提供一种缓冲机制。
多线程浅谈
bill的博客
05-19 824
Python 中的多线程通常用于处理I/O密集型任务，如网络请求、文件读写操作等，以及需要等待外部事件的情况。需要注意的是，由于Python的全局解释器锁（GIL）的限制，Python 中的多线程并不能充分利用多核处理器。如果需要充分利用多核处理器，可以考虑使用多进程（模块）或异步编程（asyncio模块）。
浅谈JAVA高并发之线程池
jin的专栏
02-19 230
效率 高并发是提高业务处理效率的有效手段，线程池（推荐ThreadPoolExecutor，其他newFixed,cached阻塞队列长度没约束，容易导致OOM）提供了将多个可独立互相不依赖的子任务并行处理，并可配置核心线程、最大、等待队列等，取代ThreadGroup 硬件约束 当然并不是线程并发度越高，效率就越高。线程执行最终到CPU层面也是时间片调用，学过计算机原理的都清楚多核CPU及调度机制，几个core才能保证并行，单个core只能保证并发。 若是CPU密集型应用，线程池大小为CPU核心数+1 若
【Java】浅谈多线程与并发（图解）
丧心病狂Loli控的博客
07-09 412
  ▇ 多线程 ▍线程状态 ▍线程通信 /* 线程之间的通信案例：消费者与生产者模型 需求： 顾客告知老板包子的种类和数量，之后放弃cpu的执行，进入waiting状态(无限等待状态)； 老板花5s做包子，做好包子后唤醒顾客 注意： 1.顾客与老板线程必须用同步代码块包裹起来，保证只有一个在执行 2.同步使用的锁必须保证唯一 */ public class Hello { public static void main(String[] args)
17.12 C++并发与多线程-补充知识、线程池浅谈、数量谈与总结
migu123的专栏
02-03 263
C++11中引入了多线程开发接口，从而使程序员脱离了以往在不同的操作系统平台下要用不同的线程库开发接口来实现多线程程序开发的尴尬境地，实现了可以通过C++语言本身提供的接口实现跨平台统一开发多线程程序的心愿，降低了学习成本，提高了程序的可移植性。 当然，当下C++11支撑的线程功能可能还不算太强大和成熟，但已经足够应付绝大部分开发需求了。同时，C++标准也在不断进化，所以有理由相信，C++对多线程的支持会越来越好，功能会越来越强大。 当然，也许开发中会遇到C++11标准线程库中的功能和具体
浅谈多线程
qq_41740469的博客
05-18 112
进程？线程？多任务？ 电脑中运行着很多软件程序，如QQ、微信、浏览器、酷狗音乐、优酷视频等等，每个软件其实就是一个进程。而线程则是进程中的一个分支。一个进程中至少包括一个线程。线程可以理解为提高程序运行的效率，或者各司其职，如QQ中既可以同时打字聊天也可以语音，再比如高速路有三个车道，车辆就可以同时跑，充分利用道路，大大提高了通行效率。 ...
线程基础学习：浅谈线程等待、通知和线程池，
weixin_45309825的博客
12-14 799
线程的等待和通知 等待和通知是Object类下的方法，但只有锁对象才能调用，如： wait()：让当前线程进入等待状态，直到被通知才能执行； wait(long)：让当前线程进入等待状态，同时给他设置一个等待的时间，直到被通知或者时间结束； notify()：随机通知一个正在等待的线程，让其开始执行； notifyAll()：通知所有正在等待的线程 注意：必须是锁对象，否则会抛出IllegalMonitorStateException /** * *通过锁对象将线程等待，5秒后通知该线程执行
浅谈几种服务器端模型——多线程并发式（线程池）
Hical的博客
11-09 3718
引言：上篇文章说到多进程并发式的服务端模型，正如上章所述，进程的频繁创建会导致服务器不堪负载，本章主要讲：线程模型和线程池的方式来提高服务端的负载能力。同时比较一下不同的模型的好处与坏处。 这里不过多的强调怎样利用线程等来创建执行体以及其他的系统调用怎样使用的。 服务端的线程使用方式一般分为三种： （1）
浅谈Java多线程
@素素~的博客
12-19 465
浅谈Java多线程
浅谈Android 的线程和线程池的使用
01-20
开发者应根据任务特性和需求选择合适的异步处理机制，如使用AsyncTask处理轻量级任务，HandlerThread进行消息驱动的任务调度，或利用线程池优化多线程环境下的资源管理。同时，注意遵循最佳实践，避免阻塞主线程，...
浅谈Java线程并发知识点
08-31
Java线程并发是多线程环境下程序执行的关键技术，它涉及到如何高效地管理多个线程，以实现并行处理和优化程序性能。本文主要探讨Java中的一些核心线程并发概念和容器。 首先，理解线程安全是至关重要的。在Java中，...
浅谈java常用的几种线程池比较
08-31
Java线程池是一种高效管理线程的工具，它允许开发者预先配置...总结来说，Java线程池是解决多线程并发问题的有效工具，但使用时需要注意潜在的风险，并通过适当配置和选择合适的线程池实现来确保系统的稳定性和性能。
浅谈python 线程池threadpool之实现
09-21
### 浅谈Python线程池ThreadPool之实现 在并发编程领域，线程池技术是一种非常高效的方法，可以显著提升程序的执行效率。Python中的`threadpool`库为开发者提供了便捷的方式来管理和利用线程池。本文将详细介绍...
浅谈java中异步多线程超时导致的服务异常
09-02
在Java编程中，异步多线程是一种常见的优化性能的方式，尤其在处理高并发场景时。这种方式通过将任务分配到不同的线程上，使得多个任务可以并行执行，从而提高程序的运行效率。然而，如果不正确地管理和控制线程，...
系统控制和管理接口：在Linux中利用电源和性能域进行平台资源抽象
csdnsqst0046的博客
08-09 877
在本文中，您可以了解到如何利用我们的方法将复杂性从Linux驱动程序（需要为每个平台编写不同的开发程序）转移到固件。由于固件已经适配了平台，因此固件知道需要采取哪些手段来配置外设。您可以了解我们如何定义逻辑性能和电源域，而不是单独处理每个平台资源。您还可以了解到我们如何努力实现这一目标，以及您如何进行尝试并做出贡献。
Linux9 Linux特殊符号
2401_82505448的博客
08-08 106
win里面的环境变量TEMP就是变量，变量名表示存放的目录。一些配置文件vi进去会有#（说明文字/某项功能）通过图中的指令，我们可以看到语言被改成了中文。例如：我们将指令注释掉，它就不再执行了。‘’也可以输出多行内容，但不能解析变量。例如：返回上一级cd..我们可以看一下它们的区别。表示两个命令同时进行。
Linux: 进程概念详解
MaoRuofeng的博客
08-11 809
截至目前，我们所认识的计算机，都是有一个个的硬件组件组成。【注意】这里的存储器指的是内存不考虑缓存情况，这里的CPU能且只能对内存进行读写，不能访问外设(输入或输出设备)外设(输入或输出设备)要输入或者输出数据，也只能写入内存或者从内存中读取。一句话，所有设备都只能直接和内存打交道。计算机就是为了完成指定的数据处理，而通过指令按指定流程完成指定功能，指令的合集就是一段程序。说白了计算机就是按照指定的指令执行流程完成对指定数据的处理。2. 操作系统(Operator System)先描述，再组织！
Linux Day1 系统编程和文件操作
最新发布
qq_63145217的博客
08-12 1051
1）使用标准库函数如fopen, fclose, fread, fwrite, fgetc, fputc, fgets, fprintf, fscanf等进行文件操作。1）用套接字（sockets）API，包括socket, bind, listen, accept, connect, send, recv等函数进行网络通信。nmemb 要写的数据块的个数（一般为sizeof（ptr））->1个1个读，到sizeof（ptr）为止。nmemb 要获取的数据块的个数，拷贝的数据块个数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值