线程池实现

最新推荐文章于 2024-08-06 10:22:43 发布
最新推荐文章于 2024-08-06 10:22:43 发布
阅读量447 收藏 6
点赞数 9
文章标签： c++ linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PM26000/article/details/136903722
版权

线程池

线程池可以使线程复用，就是执行完一个任务不会被销毁，而是可以继续执行其他任务。

主要由3部分组成：

  1. 任务队列：存储需要处理的任务，由工作的线程来处理
    • 通过线程池提供的api函数，将一个待处/理的任务添加到任务队列，或者从任务队列中删除
    • 已处理的任务会被从任务队列中删除
    • 线程池的使用者，也就是调用线程池函数往任务队列中添加任务的线程就是生产者线程
  2. 工作的线程（任务队列任务的消费者）：N个
    • 线程池中维护了一定数量的工作线程，他们的作用是是不停的读任务队列，从里边取出任务并处理。
    • 工作的线程相当于是任务队列的消费者角色
    • 如果任务队列为空，工作的线程将会被阻塞（使用条件变量或信号量来阻塞）
    • 如果阻塞之后有了新的任务，由生产者将阻塞解除，工作线程开始工作
  3. 管理者线程（不处理任务队列中的任务）：1个
    • 它的任务是周期性的对任务队列中的任务数量以及处于忙状态的工作线程个数进行检测
    • 当任务过多的时候，可以适当的创建一些新的工作线程
    • 当任务过少的时候，可以适当的销毁一些工作的线程

代码实现

任务类

//TaskQueue.h
using callback = void(*)(void*);
//任务结构体
struct Task
{
    Task()
    {
        function = nullptr;
        arg = nullptr;
    }
    Task(callback f, void* arg)
    {
        function = f;
        this->arg = arg;
    }
    callback function;
    void* arg;
};

//任务队列类
class TaskQueue
{
public:
    TaskQueue();
    ~TaskQueue();
    void addTask(Task& task);// 添加任务
    void addTask(callback func, void* arg);

    Task takeTask();// 取出一个任务

    // 获取当前队列中任务个数
    inline int taskNumber()
    {
        return m_queue.size();
    }

private:
    pthread_mutex_t m_mutex;    // 互斥锁
    std::queue<Task> m_queue;   // 任务队列
};

//TaskQueue.cpp
TaskQueue::TaskQueue() {pthread_mutex_init(&m_mutex, NULL);}

TaskQueue::~TaskQueue() {pthread_mutex_destroy(&m_mutex);}

void TaskQueue::addTask(Task& task)
{
    pthread_mutex_lock(&m_mutex);
    m_queue.push(task);
    pthread_mutex_unlock(&m_mutex);
}

void TaskQueue::addTask(callback func, void* arg)
{
    pthread_mutex_lock(&m_mutex);
    Task task;
    task.function = func;
    task.arg = arg;
    m_queue.push(task);
    pthread_mutex_unlock(&m_mutex);
}

Task TaskQueue::takeTask()
{
    Task t;
    pthread_mutex_lock(&m_mutex);
    if (m_queue.size() > 0)
    {
        t = m_queue.front();
        m_queue.pop();
    }
    pthread_mutex_unlock(&m_mutex);
    return t;
}

线程池类

//ThreadPool.h
class ThreadPool
{
public:
    ThreadPool(int min, int max);
    ~ThreadPool();
    void addTask(Task task);// 添加任务
    int getBusyNumber();    // 获取忙线程的个数 
    int getAliveNumber();   // 获取活着的线程个数

private:
    static void* worker(void* arg);  // 工作的线程的任务函数
    static void* manager(void* arg); // 管理者线程的任务函数
    void threadExit();

private:
    pthread_mutex_t m_lock;
    pthread_cond_t m_notEmpty;
    pthread_t* m_threadIDs;
    pthread_t m_managerID;
    TaskQueue* m_taskQ;
    int m_minNum;
    int m_maxNum;
    int m_busyNum;
    int m_aliveNum;
    int m_exitNum;
    bool m_shutdown = false;
};

//ThreadPool.cpp
ThreadPool::ThreadPool(int minNum, int maxNum)
{
    // 实例化任务队列
    m_taskQ = new TaskQueue;
    do {
        // 初始化线程池
        m_minNum = minNum;
        m_maxNum = maxNum;
        m_busyNum = 0;
        m_aliveNum = minNum;

        // 根据线程的最大上限给线程数组分配内存
        m_threadIDs = new pthread_t[maxNum];
        if (m_threadIDs == nullptr)
        {
            cout << "malloc thread_t[] 失败...." << endl;;
            break;
        }
        // 初始化
        memset(m_threadIDs, 0, sizeof(pthread_t) * maxNum);
        // 初始化互斥锁,条件变量
        if (pthread_mutex_init(&m_lock, NULL) != 0 ||
            pthread_cond_init(&m_notEmpty, NULL) != 0)
        {
            cout << "init mutex or condition fail..." << endl;
            break;
        }
        
        // 根据最小线程个数, 创建线程
        for (int i = 0; i < minNum; ++i)
        {
            pthread_create(&m_threadIDs[i], NULL, worker, this);
            cout << "创建子线程, ID: " << to_string(m_threadIDs[i]) << endl;
        }
        // 创建管理者线程, 1个
        pthread_create(&m_managerID, NULL, manager, this);
    } while (0);
}

ThreadPool::~ThreadPool()
{
    m_shutdown = 1;
    // 销毁管理者线程
    pthread_join(m_managerID, NULL);
    // 唤醒所有消费者线程
    for (int i = 0; i < m_aliveNum; ++i)
    {
        pthread_cond_signal(&m_notEmpty);
    }

    if (m_taskQ) delete m_taskQ;
    if (m_threadIDs) delete[]m_threadIDs;
    pthread_mutex_destroy(&m_lock);
    pthread_cond_destroy(&m_notEmpty);
}

void ThreadPool::addTask(Task task)
{
    if (m_shutdown)
        return;
    // 添加任务，不需要加锁，任务队列中有锁
    m_taskQ->addTask(task);
    // 唤醒工作的线程
    pthread_cond_signal(&m_notEmpty);
}

int ThreadPool::getAliveNumber()
{
    int threadNum = 0;
    pthread_mutex_lock(&m_lock);
    threadNum = m_aliveNum;
    pthread_mutex_unlock(&m_lock);
    return threadNum;
}

int ThreadPool::getBusyNumber()
{
    int busyNum = 0;
    pthread_mutex_lock(&m_lock);
    busyNum = m_busyNum;
    pthread_mutex_unlock(&m_lock);
    return busyNum;
}


// 工作线程任务函数
void* ThreadPool::worker(void* arg)
{
    ThreadPool* pool = static_cast<ThreadPool*>(arg);
    // 一直不停的工作
    while (true)
    {
        // 访问任务队列(共享资源)加锁
        pthread_mutex_lock(&pool->m_lock);
        // 判断任务队列是否为空, 如果为空工作线程阻塞
        while (pool->m_taskQ->taskNumber() == 0 && !pool->m_shutdown)
        {
            cout << "thread " << to_string(pthread_self()) << " waiting..." << endl;
            // 阻塞线程
            pthread_cond_wait(&pool->m_notEmpty, &pool->m_lock);
            // 解除阻塞之后, 判断是否要销毁线程
            if (pool->m_exitNum > 0)
            {
                pool->m_exitNum--;
                if (pool->m_aliveNum > pool->m_minNum)
                {
                    pool->m_aliveNum--;
                    pthread_mutex_unlock(&pool->m_lock);
                    pool->threadExit();
                }
            }
        }
        // 判断线程池是否被关闭了
        if (pool->m_shutdown)
        {
            pthread_mutex_unlock(&pool->m_lock);
            pool->threadExit();
        }

        // 从任务队列中取出一个任务
        Task task = pool->m_taskQ->takeTask();
        // 工作的线程+1
        pool->m_busyNum++;
        // 线程池解锁
        pthread_mutex_unlock(&pool->m_lock);
        // 执行任务
        cout << "thread " << to_string(pthread_self()) << " start working..." << endl;
        task.function(task.arg);
        delete task.arg;
        task.arg = nullptr;

        // 任务处理结束
        cout << "thread " << to_string(pthread_self()) << " end working...";
        pthread_mutex_lock(&pool->m_lock);
        pool->m_busyNum--;
        pthread_mutex_unlock(&pool->m_lock);
    }
    return nullptr;
}


// 管理者线程任务函数
void* ThreadPool::manager(void* arg)
{
    ThreadPool* pool = static_cast<ThreadPool*>(arg);
    // 如果线程池没有关闭, 就一直检测
    while (!pool->m_shutdown)
    {
        // 每隔5s检测一次
        sleep(5);
        // 取出线程池中的任务数和线程数量
        //  取出工作的线程池数量
        pthread_mutex_lock(&pool->m_lock);
        int queueSize = pool->m_taskQ->taskNumber();
        int liveNum = pool->m_aliveNum;
        int busyNum = pool->m_busyNum;
        pthread_mutex_unlock(&pool->m_lock);

        // 创建线程
        const int NUMBER = 2;
        // 当前任务个数>存活的线程数 && 存活的线程数<最大线程个数
        if (queueSize > liveNum && liveNum < pool->m_maxNum)
        {
            // 线程池加锁
            pthread_mutex_lock(&pool->m_lock);
            int num = 0;
            for (int i = 0; i < pool->m_maxNum && num < NUMBER
                && pool->m_aliveNum < pool->m_maxNum; ++i)
            {
                if (pool->m_threadIDs[i] == 0)
                {
                    pthread_create(&pool->m_threadIDs[i], NULL, worker, pool);
                    num++;
                    pool->m_aliveNum++;
                }
            }
            pthread_mutex_unlock(&pool->m_lock);
        }

        // 销毁多余的线程
        // 忙线程*2 < 存活的线程数目 && 存活的线程数 > 最小线程数量
        if (busyNum * 2 < liveNum && liveNum > pool->m_minNum)
        {
            pthread_mutex_lock(&pool->m_lock);
            pool->m_exitNum = NUMBER;
            pthread_mutex_unlock(&pool->m_lock);
            for (int i = 0; i < NUMBER; ++i)
            {
                pthread_cond_signal(&pool->m_notEmpty);
            }
        }
    }
    return nullptr;
}

// 线程退出
void ThreadPool::threadExit()
{
    pthread_t tid = pthread_self();
    for (int i = 0; i < m_maxNum; ++i)
    {
        if (m_threadIDs[i] == tid)
        {
            cout << "threadExit() function: thread " 
                << to_string(pthread_self()) << " exiting..." << endl;
            m_threadIDs[i] = 0;
            break;
        }
    }
    pthread_exit(NULL);
}

main

void taskFunc(void* arg)
{
    int num = *(int*)arg;
    std::cout << "thread " << pthread_self() << " is working, number = " << num << std::endl;
    sleep(1);
}

int main()
{
    // 创建线程池
    ThreadPool pool(3, 10);
    for(int i = 0; i < 100; i++){
        int* num = new int(i + 100);
        pool.addTask(Task(taskFunc, num));
    }
    sleep(20);
    return 0;
}

创建100个任务，可以看到执行结果

img

PM2600
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
线程池实现方式
qq_41206954的博客
07-12 1027
线程池练习记录
java动态线程池_可动态调节参数的线程池实现
weixin_42306503的博客
02-18 1047
背景线程池是一种基于池化思想管理线程的工具，使用线程池可以减少创建销毁线程的开销，避免线程过多导致系统资源耗尽。在高并发的任务处理场景，线程池的使用是必不可少的。在双11主图价格表达项目中为了提升处理性能，很多地方使用到了线程池。随着线程池的使用，逐渐发现一个问题，线程池的参数如何设置？线程池参数中有三个比较关键的参数，分别是corePoolSize(核心线程数)、maximumPoolSize(...
Java线程池实现原理
relosy的博客
03-17 668
参考：Java线程池实现原理及其在美团业务中的实践 - 美团技术团队 (meituan.com) 一、线程池是什么 线程池是一种对线程进行池化管理的思想和工具，广泛应用于多线程服务器中 线程的创建和销毁都会带来很多额外开销降低了服务器性能，线程池可以维护多个线程来执行任务，并且可以通过任务队列来缓存任务提高了并发能力。 线程池优点 降低资源消耗：池化技术可以减少线程的创建和销毁带来的性能损耗 提高响应速度：任务到达后可以无需等待线程创建直接执行 提高线程的可管理性：使用线程池可以对线程、任务进行监控和管理
线程池实现目录拷贝
我真的好难的博客
08-25 1679
线性池实现目录拷贝
异步编程-线程池实现异步编程
yyy
08-13 946
如上代码确实可以在main函数所在线程获取到异步任务的执行结果，但是main线程必须以阻塞的代价来获取结果，在异步任务执行完毕前，main函数所在线程就不能做其他事情了，这显然不是我们所需要的，具体怎么解决这个问题，下章揭晓。上面代码0创建了一个线程池，这里我们设置线程池核心线程个数为当前物理机的CPU核数，最大线程个数为当前物理机CPU核数的2倍；设置线程池阻塞队列的大小为5；如上面代码所示，main函数所在线程只需要把两个任务提交到线程池后就可以做自己的事情了，具体两个任务是由线程池中的线程执行。...
详述Java线程池实现原理
养歌的博客
01-06 2437
线程池是什么 线程池就是创建若干个可执行的线程放入一个池（容器）中，有任务需要处理时，会提交到线程池中的任务队列，处理完之后线程并不会被销毁，而是仍然在线程池中等待下一个任务。 使用线程池有什么好处 降低资源消耗：通过重复利用现有的线程来执行任务，避免多次创建和销毁线程 提高响应速度：因为省去了创建线程这个步骤，所以在拿到任务时，可以立刻开始执行 提供附加功能：线程池的可拓展性使得我们可以自己加入新的功能，比如说定时、延时来执行某些线程 提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统
多线程实现（二）——线程池实现多线程
冉木的博客
09-26 2302
系列文章目录 文章目录系列文章目录前言一、线程池的优势有哪些？二、线程池实现多线程实践2.1、第一种： 创建线程池对象；创建单个线程的线程池对象2.2、第二种： 创建固定数量的线程池(指定核心线程数数量)2.3、第三种：创建一个按照计划执行的线程池2.4、第四种：创建一个自动增长的线程池总结 前言 上一篇文章讲了线程的三种实现 方式，但在实际项目开发中，基本用不到找这些方法，而通常用线程池来实现，为什么这样子呢？是因为我们继承Thread、实现Runable、实现FutureTask这三种线程方法无法
Java线程池实现秒杀功能
pan_junbiao的博客
11-27 3241
1、简单实例 【实例】Java使用多线程和Redis实现一个1000人秒杀100部手机的实例。 （1）秒杀实现（SecondKill.java）：创建多线程，并利用Redis的事务功能，实现秒杀功能。 package com.pjb.seckill; import redis.clients.jedis.Jedis; import redis.clients.jedis.Transaction; import java.util.List; /** * 秒杀抢购 * @author pan_
线程池实现“线程复用”的原理？
Javazzc123的专栏
08-31 1891
如流程图所示，当提交任务后，线程池首先会检查当前线程数，如果此时线程数小于核心线程数，比如最开始线程数量为 0，则新建线程并执行任务，随着任务的不断增加，线程数会逐渐增加并达到核心线程数，此时如果仍有任务被不断提交，就会被放入 workQueue 任务队列中，等待核心线程执行完当前任务后重新从 workQueue 中提取正在等待被执行的任务。线程池可以把线程和任务进行解耦，线程归线程，任务归任务，摆脱了之前通过 Thread 创建线程时的一个线程必须对应一个任务的限制。...
通过EasyExcel+线程池实现百万级数据从Excel导入到数据库
03-26
在处理大量数据导入数据库的场景中，使用...通过以上步骤，可以利用EasyExcel和线程池实现百万级数据从Excel导入到数据库的功能。这种方式可以提高数据处理的效率，减少内存占用，并且能够更好地利用多核CPU的优势。
线程池实现thpool
06-17
"thpool"是一个开源的、轻量级的线程池实现，它为开发者提供了一个简单易用的接口，用于在Linux环境下创建和管理线程池。 thpool的实现主要包含以下几个核心组件和概念： 1. **线程池结构体**：thpool_t，这个...
Django异步任务线程池实现原理
09-18
主要介绍了Django异步任务线程池实现原理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 178
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
C++ STL copy_backward, move_backward 用法
08-04 228
此处需要解释一下：从后向前并不是逆序，它的意思是: 源容器和目标容器都从尾部开始，然后向前迭代，执行拷贝/移动操作。反向（从后向前的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
C++ STL copy, move 用法
08-04 244
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
【C++】输入输出
2401_83948390的博客
08-02 572
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
C++｜设计模式（八）｜⭐️工厂模式？错！是工厂模式群！
糖炒栗子
08-02 931
首先我们按照与 Employee 类相同的方式来创建所有不同项目对应的基类（父类）Project，在这个类中我们还定义了与项目相关的接口 assignTo ，这个接口可以将某个项目指派给对应账户ID的员工，还是相同的方式我们定义 ITProject 与 UIProject 这两个不同项目的子类，并提供 assignTo 接口的不同实现。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值