19.手写线程池

最新推荐文章于 2024-08-09 10:25:03 发布
最新推荐文章于 2024-08-09 10:25:03 发布
阅读量715 收藏
点赞数 32
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62318955/article/details/134489948
版权

手写线程池

需求：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <thread>
#include <functional>
#include <vector>
#include <unordered_map>
#include <queue>
#include <mutex>
#include <condition_variable>

using namespace std;

bool is_prime(int x) {
    for (int i = 2; i * i <= x; i++) {
        if (x % i == 0) return false;
    }
    return true;
}

int prime_count_test(int l, int r) {
    int ans = 0;
    for (int i = l; i <= r; i++) {
        ans += is_prime(i);
    }
    return ans;
}

void worker(int l, int r, int &ret) {
    ret = prime_count_test(l, r);
    return ;
}

int main() {
    #define batch 5000000
    // 创建一个线程池
    ThreadPool tp(5);
    int ret[10];
    // 把任务丢进任务队列中，等待执行
    for (int i = 0, j = 1; i < 10; i++, j += batch) {
        tp.add_task(worker, j, j + batch - 1, ref(ret[i]));
    }
    // 等待线程池结束，并销毁线程池
    tp.stop();
    int ans = 0;
    for (auto x : ret) ans += x;
    cout << ans << endl;
    return 0;
}

​ 使这段代码可以正常运行，这段代码是暴力求素数个数的一个测试用例

实现：

​ 我们先来分析一下需求（我们想要创建哪些类，可以满足我们使用线程池的需求）：

  • 首先肯定得有一个线程池的类
  • 其次线程还得从任务队列中取任务，所有我们还有一个任务队列的类，但是呢？由于STL中有已经封装好的，所有可以直接使用。
  • 允许创建具有任意函数和相应参数的任务的一个类，我们这里叫做Task类。

我们来依次实现一下，先实现一个简单的类（Task）：

class Task {
public:
    template<typename FUN_C, typename ...ARGS>
    Task(FUN_C fun, ARGS ...args) {
        func = bind(fun, forward<ARGS>(args)...);
    }
    void run() {
        func();
    }

private:
    function<void()> func;
};
  • 由于我们得接收任意函数的一个类，所有在这里我们得使用变参模板来实现这个需求，
  • 我们还得把任务给打包好，所有我们这里使用的是bind函数来实现这个需求；
  • 我们得用function函数来接收和调用这个任务。

由于任务队列的类，STL中有封装好的，所有我们直接来写我们主要的线程池类：

先来实现一个（ThreadPool tp(5);）
class ThreadPool {
public:
    ThreadPool(int n = 1) : threads(n), thread_size(n), starting(false) {
        this->start();
        return ;
    }
    void worker() {
        while (1) {
			// 取任务
            // 执行任务
        }
        return ;
    }
    void start() {
        if (starting == true) return ;
        for (int i = 0; i < thread_size; i++) {
            threads[i] = new thread(&ThreadPool::worker, this);
        }
        starting = true;
        return ;
    }

private:
    
    bool starting;
    queue<Task *> task_que;
    vector<thread *> threads;
    int thread_size;
};

  1. 构造函数:

    ThreadPool(int n = 1) : threads(n), thread_size(n), starting(false) {
    this->start();
    return ;
}

    这是线程池的构造函数，接受一个整数参数n，默认值为1。它初始化了线程池的一些成员变量，然后调用了start函数启动线程池。

  2. start函数:

    void start() {
    if (starting == true) return ;
    for (int i = 0; i < thread_size; i++) {
        threads[i] = new thread(&ThreadPool::worker, this);
    }
    starting = true;
    return ;
}

    start函数用于启动线程池。它首先检查starting变量，如果线程池已经启动，就直接返回。然后，它通过循环创建了指定数量的线程，每个线程都执行worker函数。

  3. worker函数:

    void worker() {
    while (1) {
        // 取任务
        // 执行任务
    }
    return ;
}

    worker函数是线程的主体函数，实现了线程的具体工作。它使用一个无限循环来不断地从任务队列中取出任务并执行。这里的具体任务处理逻辑需要根据实际需求来添加。

  4. 成员变量:

    bool starting;
queue<Task *> task_que;
vector<thread *> threads;
int thread_size;
    • starting标志表示线程池是否已经启动。
    • task_que是一个任务队列，用于存储需要线程池执行的任务。
    • threads是一个存储线程指针的向量。
    • thread_size表示线程池中线程的数量。
再来实现一个tp.add_task(worker, j, j + batch - 1, ref(ret[i]));
class ThreadPool {
public:
    ThreadPool(int n = 1) : threads(n), thread_size(n), starting(false) {
        this->start();
        return ;
    }
    void worker() {
        while (1) {
            Task *t = get_task();
            t->run();
            delete t;
        }
        return ;
    }
    void start() {
        if (starting == true) return ;
        for (int i = 0; i < thread_size; i++) {
            threads[i] = new thread(&ThreadPool::worker, this);
        }
        starting = true;
        return ;
    }
    template<typename FUN_C, typename ...ARGS>
    void add_task(FUN_C fun, ARGS ...args) {
        unique_lock<mutex> lock(m_mutex);
        task_que.push(new Task(fun, forward<ARGS>(args)...));
        m_cond.notify_one();
        return ;
    }

private:
    Task *get_task() {
        unique_lock<mutex> lock(m_mutex);
        while (task_que.empty()) m_cond.wait(lock);
        Task *t = task_que.front();
        task_que.pop();
        return t;
    }

    std::mutex m_mutex;
    std::condition_variable m_cond;
    bool starting;
    queue<Task *> task_que;
    vector<thread *> threads;
    int thread_size;
};

  1. worker函数:

    void worker() {
    while (1) {
        Task *t = get_task();
        t->run();
        delete t;
    }
    return ;
}

    worker函数是线程的主体函数，实现了线程的具体工作。它通过get_task函数获取任务，执行任务的run函数，然后释放任务的内存。

  2. add_task函数:

    template<typename FUN_C, typename ...ARGS>
void add_task(FUN_C fun, ARGS ...args) {
    unique_lock<mutex> lock(m_mutex);
    task_que.push(new Task(fun, forward<ARGS>(args)...));
    m_cond.notify_one();
    return ;
}

    add_task函数用于向任务队列中添加任务。它使用了可变参数模板，允许传递任意类型和数量的参数。添加任务后通过条件变量通知等待中的线程。

  3. get_task函数:

    Task *get_task() {
    unique_lock<mutex> lock(m_mutex);
    while (task_que.empty()) m_cond.wait(lock);
    Task *t = task_que.front();
    task_que.pop();
    return t;
}

    get_task函数从任务队列中获取任务，如果队列为空，则线程等待条件变量的通知。获取到任务后，从队列中移除，并返回任务指针。

  4. 成员变量:

    std::mutex m_mutex;
std::condition_variable m_cond;
bool starting;
queue<Task *> task_que;
vector<thread *> threads;
int thread_size;
unordered_map<decltype(this_thread::get_id()), bool> running;
    • m_mutex是互斥锁，用于保护对任务队列的访问。
    • m_cond是条件变量，用于线程之间的同步。
实现tp.stop();
class ThreadPool {
public:
    ThreadPool(int n = 1) : threads(n), thread_size(n), starting(false) {
        this->start();
        return ;
    }
    void worker() {
        auto id = this_thread::get_id();
        running[id] = true;
        while (running[id]) {
            Task *t = get_task();
            t->run();
            delete t;
        }
        return ;
    }
    void start() {
        if (starting == true) return ;
        for (int i = 0; i < thread_size; i++) {
            threads[i] = new thread(&ThreadPool::worker, this);
        }
        starting = true;
        return ;
    }
    template<typename FUN_C, typename ...ARGS>
    void add_task(FUN_C fun, ARGS ...args) {
        unique_lock<mutex> lock(m_mutex);
        task_que.push(new Task(fun, forward<ARGS>(args)...));
        m_cond.notify_one();
        return ;
    }
    void stop() {
        if (starting == false) return ;
        for (int i = 0; i < thread_size; i++) {
            task_que.push(new Task(&ThreadPool::stop_thread, this));
        }
        for (int i = 0; i < thread_size; i++) {
            threads[i]->join();
        }
        for (int i = 0; i < thread_size; i++) {
            delete threads[i];
            threads[i] = nullptr;
        }
        starting = false;
        return ;
    }
    ~ThreadPool() {
        this->stop();
        while (!task_que.empty()) {
            delete task_que.front();
            task_que.pop();
        }
        return ;
    }

private:
    void stop_thread() {
        auto id = this_thread::get_id();
        running[id] = false;
        return ;
    }
    Task *get_task() {
        unique_lock<mutex> lock(m_mutex);
        while (task_que.empty()) m_cond.wait(lock);
        Task *t = task_que.front();
        task_que.pop();
        return t;
    }

    std::mutex m_mutex;
    std::condition_variable m_cond;
    bool starting;
    queue<Task *> task_que;
    vector<thread *> threads;
    int thread_size;
    unordered_map<decltype(this_thread::get_id()), bool> running;
};

  1. worker函数:

    void worker() {
    auto id = this_thread::get_id();
    running[id] = true;
    while (running[id]) {
        Task *t = get_task();
        t->run();
        delete t;
    }
    return ;
}

    worker函数是线程的主体函数，实现了线程的具体工作。在循环中，它通过get_task函数获取任务，执行任务的run函数，然后释放任务的内存。此外，每个线程都有一个运行状态，保存在running映射中。

  2. add_task函数:

    template<typename FUN_C, typename ...ARGS>
void add_task(FUN_C fun, ARGS ...args) {
    unique_lock<mutex> lock(m_mutex);
    task_que.push(new Task(fun, forward<ARGS>(args)...));
    m_cond.notify_one();
    return ;
}

    add_task函数用于向任务队列中添加任务。它使用了可变参数模板，允许传递任意类型和数量的参数。添加任务后通过条件变量通知等待中的线程。

  3. stop函数:

    void stop() {
    if (starting == false) return ;
    for (int i = 0; i < thread_size; i++) {
        task_que.push(new Task(&ThreadPool::stop_thread, this));
    }
    for (int i = 0; i < thread_size; i++) {
        threads[i]->join();
    }
    for (int i = 0; i < thread_size; i++) {
        delete threads[i];
        threads[i] = nullptr;
    }
    starting = false;
    return ;
}

    stop函数用于停止线程池。它向任务队列中添加了一个特殊的任务，该任务调用stop_thread函数，使所有线程退出循环。接着，等待每个线程完成，然后释放线程资源。

  4. stop_thread函数:

    void stop_thread() {
    auto id = this_thread::get_id();
    running[id] = false;
    return ;
}

    stop_thread函数用于在每个线程中调用，设置相应线程的运行状态为false，从而退出循环。

  5. 析构函数:

    ~ThreadPool() {
    this->stop();
    while (!task_que.empty()) {
        delete task_que.front();
        task_que.pop();
    }
    return ;
}

    析构函数在对象销毁时会调用，这里调用了stop函数以确保线程池停止，并释放任务队列中的任务。

    running是一个unordered_map，用于跟踪线程的运行状态。

完整代码：

/*************************************************************************
        > File Name: thread_pool.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Sat Nov 18 18:18:18 2023
 ************************************************************************/

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <thread>
#include <functional>
#include <vector>
#include <unordered_map>
#include <queue>
#include <mutex>
#include <condition_variable>

using namespace std;

class Task {
public:
    template<typename FUN_C, typename ...ARGS>
    Task(FUN_C fun, ARGS ...args) {
        func = bind(fun, forward<ARGS>(args)...);
    }
    void run() {
        func();
    }

private:
    function<void()> func;
};

class ThreadPool {
public:
    ThreadPool(int n = 1) : threads(n), thread_size(n), starting(false) {
        this->start();
        return ;
    }
    void worker() {
        auto id = this_thread::get_id();
        running[id] = true;
        while (running[id]) {
            Task *t = get_task();
            t->run();
            delete t;
        }
        return ;
    }
    void start() {
        if (starting == true) return ;
        for (int i = 0; i < thread_size; i++) {
            threads[i] = new thread(&ThreadPool::worker, this);
        }
        starting = true;
        return ;
    }
    template<typename FUN_C, typename ...ARGS>
    void add_task(FUN_C fun, ARGS ...args) {
        unique_lock<mutex> lock(m_mutex);
        task_que.push(new Task(fun, forward<ARGS>(args)...));
        m_cond.notify_one();
        return ;
    }
    void stop() {
        if (starting == false) return ;
        for (int i = 0; i < thread_size; i++) {
            task_que.push(new Task(&ThreadPool::stop_thread, this));
        }
        for (int i = 0; i < thread_size; i++) {
            threads[i]->join();
        }
        for (int i = 0; i < thread_size; i++) {
            delete threads[i];
            threads[i] = nullptr;
        }
        starting = false;
        return ;
    }
    ~ThreadPool() {
        this->stop();
        while (!task_que.empty()) {
            delete task_que.front();
            task_que.pop();
        }
        return ;
    }

private:
    void stop_thread() {
        auto id = this_thread::get_id();
        running[id] = false;
        return ;
    }
    Task *get_task() {
        unique_lock<mutex> lock(m_mutex);
        while (task_que.empty()) m_cond.wait(lock);
        Task *t = task_que.front();
        task_que.pop();
        return t;
    }

    std::mutex m_mutex;
    std::condition_variable m_cond;
    bool starting;
    queue<Task *> task_que;
    vector<thread *> threads;
    int thread_size;
    unordered_map<decltype(this_thread::get_id()), bool> running;
};

bool is_prime(int x) {
    for (int i = 2; i * i <= x; i++) {
        if (x % i == 0) return false;
    }
    return true;
}

int prime_count_test(int l, int r) {
    int ans = 0;
    for (int i = l; i <= r; i++) {
        ans += is_prime(i);
    }
    return ans;
}

void worker(int l, int r, int &ret) {
    ret = prime_count_test(l, r);
    return ;
}

int main() {
    #define batch 5000000
    // 创建一个线程池
    ThreadPool tp(5);
    int ret[10];
    // 把任务丢进任务队列中，等待执行
    for (int i = 0, j = 1; i < 10; i++, j += batch) {
        tp.add_task(worker, j, j + batch - 1, ref(ret[i]));
    }
    // 等待线程池结束，并销毁线程池
    tp.stop();
    int ans = 0;
    for (auto x : ret) ans += x;
    cout << ans << endl;
    return 0;
}
拾雪藏于春
关注
  • 32
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
线程池（四）：手写线程池实战
bugmiao的博客
12-10 255
一、线程池实战例子 项目背景：需要查出一百个用户的信息，并且给他们的邮箱发送邮件，打印出最终结果 用户类 public class User { private Integer id; private String email; public User(Integer id, String email) { this.id =id; this.email =email; } public String getEmail() {
Java手写线程池的实现方法
08-27
Java手写线程池的实现方法 Java手写线程池的实现方法是指通过编写 Java 代码来实现一个线程池，线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台...
手写线程池
weixin_57128596的博客
04-20 280
package com.example.juc.ThreadPool; import lombok.extern.slf4j.Slf4j; import java.util.ArrayDeque; import java.util.Deque; import java.util.HashSet; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import java.util.conc.
手写线程池实战
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
06-18 436
有经典，有干货，微信搜索【李子捌】关注这个傻瓜式坚持的程序员。 往期回顾-线程池技术详解 线程池实战 简介： 上文讲述了怎么写一个简单的数据库连接池，试想一下，当服务端接收到来自客户端的成白上千个连接请求时，如果每次我们都为其创建一个线程去执行任务，执行完毕后销毁线程，这肯定不是一个好的解决办法。我们知道线程的创建和销毁是要消耗系统资源的，那么我们就可以从这个方面入手来控制资源的浪费。 ​ 线程池描述： 线程池技术是一种池化思想，也就是提前预置若干数量的线程，并且线程不能由用户直接控制，在这个前提下重复.
手写Java的线程池
weixin_43939924的博客
07-26 302
简单实现了一个Java的线程池 阻塞队列 线程池 测试代码 测试结果
剑指JUC原理-12.手写简易版线程池思路
爱吃知识的土豆倪的博客
11-05 577
线程是一个系统资源，没创建一个新的线程就会占用一定的内存，会用栈内存，如果是高并发情况下，一下子来了很多任务，如果我为每个认为都创建一个新的线程，对内存的占用是非常大的，甚至可能会出现内存泄漏问题。自定义线程池其实包含几个组件：生产者，消费者，阻塞队列，两边的速率由阻塞队列等待。
java线程池面试题-----手写线程池实战
qq_42795723的博客
08-01 246
一、线程池实战例子 项目背景：需要查出一百个用户的信息，并且给他们的邮箱发送邮件，打印出最终结果 用户类 public class User { private Integer id; private String email; public User(Integer id, String email) { this.id =id; this.email =email; } public String getEmail() {
[多线程] C++ 手写线程池的设计
zlllc的博客
01-26 1052
实现一个简单的C++自定义线程池。
Java 手写线程池
ThatWeKnow
08-05 381
源码：https://github.com/Bit-urd/knowledge-base/tree/master/java-se/src/com/biturd/knowledgebase/thread/pool 思路 类比数据库连接池。数据库连接池复用的是Connection，池化技术通用的：最小个数、最大个数、活跃时间、线程池容器[核心]:一般为队列。[通用的就不写了，写点特有的] 线程池复用的是线程，目的是减少向操作系统申请线程避免上下文切换。正常情况下线程执行完就结束了，就死亡了。无法复用。 要.
手写一个线程池
wenpan的博客
03-13 877
实现了基本的线程池功能，比如 提交不需要返回结果的任务 提交需要返回值的任务 自定义线程池各个参数 线程池中的worker执行完任务后自动去队列里获取一个任务来执行 自定义拒绝策略 需要优化的功能 更精细的并发控制 根据线程池中worker的具体情况来判断是否要销毁当前worker 当然，最正宗的还是要看 大哥李 开发的线程池 ①、自定义线程池 public class MyThreadPool { /** * 线程池状态（默认0，正在运行，1线程池关闭中，2线程池终结）
手写windows下c++线程池
01-12
线程池主体由两个线程构成 1、工作线程：不断的从任务队列里读取任务并且执行 2、管理线程：三秒中查询一次，根据任务和线程数量的比较来杀死线程或者生成线程 然后在需要调用线程池的地方往任务队列里添加函数就...
linux 手写 zinnia.zip
10-07
linux 手写 zinnia.ziplinux 手写 zinnia.ziplinux 手写 zinnia.ziplinux 手写 zinnia.ziplinux 手写 zinnia.ziplinux 手写 zinnia.ziplinux 手写 zinnia.ziplinux 手写 zinnia.ziplinux 手写 zinnia.ziplinux 手写 ...
16.手写模拟器.zip
10-02
手写模拟器.zip”通常指的是一个包含有关手写模拟或数字化手写技术的压缩文件包。这个标题暗示我们可能在压缩包内找到一个用于模拟手写过程的应用程序或者一套工具，这可能是为了教学、设计、编程或者其他与手写识别...
手写模拟器v2.0.zip
09-01
《手写模拟器v2.0：科技与艺术的完美结合》 在信息化时代，效率成为了生活和工作中的关键词。然而，在某些特定场合，手写的独特魅力仍然无法被电子文字所替代，比如书法、签名或者个人笔记。"手写模拟器v2.0.zip...
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 206
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 196
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 325
STL中的迭代器失效（vector为例）
C++ - 函数重载
jiaowenjie的专栏
08-06 317
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
java 手写线程池
09-01
要手写一个简单的线程池，你可以按照以下步骤进行： 1. 创建一个任务队列，用于存储待执行的任务。 2. 创建一个固定数量的线程池，用于执行任务。 3. 每当有任务提交到线程池时，将任务添加到任务队列中。 4. ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值