C++03线程池：基于POSIX线程库的实现

最新推荐文章于 2025-08-23 09:39:22 发布
原创 最新推荐文章于 2025-08-23 09:39:22 发布 · 991 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #线程池 #线程

C++03线程池：基于POSIX线程库的实现

什么是线程池？

线程池是一种并发编程模式，它预先创建一定数量的工作线程，这些线程会循环等待并执行提交的任务。这种模式避免了频繁创建和销毁线程带来的性能开销，是处理大量并发任务的高效解决方案。

在C++11标准之前，C++语言本身并没有提供线程库，因此线程池的实现需要依赖操作系统提供的线程接口。本文将基于POSIX线程库（pthread）实现一个兼容C++03标准的线程池。

线程池的核心优势

  1. 减少线程创建销毁开销：线程的创建和销毁涉及内核态操作，成本较高。线程池通过复用已创建的线程，显著减少这些操作。

  2. 控制资源消耗：限制并发线程的最大数量，避免因创建过多线程导致的系统资源耗尽和调度开销增加。

  3. 提高任务响应速度：线程预先创建并处于就绪状态，任务提交后可立即执行，无需等待线程创建。

  4. 简化并发编程：封装了线程管理和同步细节，开发者只需关注任务逻辑。

线程池的核心组件

一个典型的线程池包含以下核心组件：

  • 工作线程：预先创建的线程，负责从任务队列中获取并执行任务
  • 任务队列：存储待执行任务的数据结构，通常为先进先出（FIFO）队列
  • 同步机制：确保多线程安全访问任务队列的互斥锁和条件变量
  • 线程管理接口：用于创建线程池、提交任务、调整线程数量和销毁线程池

C++03线程池实现

头文件（thread_pool.h）

#ifndef THREAD_POOL_H
#define THREAD_POOL_H

#include <vector>
#include <queue>
#include <pthread.h>
#include <cstddef>
#include <stdexcept>
#include <cassert>

// 任务基类，用于类型擦除
class Task {
public:
    virtual ~Task() {}
    virtual void execute() = 0;
};

// 具体任务模板类
template<typename Result>
class ResultTask : public Task {
public:
    // 函数指针类型定义
    typedef Result (*Function)();

    ResultTask(Function func) : func_(func), completed_(false) {}

    void execute() {
        result_ = func_();
        completed_ = true;
    }

    Result get_result() {
        // 简单的忙等待（实际应用可考虑添加超时机制）
        while (!completed_) {
            // 让出CPU时间片
            sched_yield();
        }
        return result_;
    }

private:
    Function func_;       // 任务函数
    Result result_;       // 任务结果
    bool completed_;      // 完成标志
};

// 无返回值任务特化
template<>
class ResultTask<void> : public Task {
public:
    typedef void (*Function)();

    ResultTask(Function func) : func_(func), completed_(false) {}

    void execute() {
        func_();
        completed_ = true;
    }

    void get_result() {
        while (!completed_) {
            sched_yield();
        }
    }

private:
    Function func_;
    bool completed_;
};

// 线程池类
class ThreadPool {
public:
    // 构造函数：指定线程数量
    explicit ThreadPool(size_t num_threads) 
        : stop_(false), num_threads_(num_threads) {
        // 初始化互斥锁
        if (pthread_mutex_init(&mutex_, NULL) != 0) {
            throw std::runtime_error("Failed to initialize mutex");
        }
        
        // 初始化条件变量
        if (pthread_cond_init(&cond_, NULL) != 0) {
            pthread_mutex_destroy(&mutex_);
            throw std::runtime_error("Failed to initialize condition variable");
        }
        
        // 创建工作线程
        threads_.resize(num_threads_);
        for (size_t i = 0; i < num_threads_; ++i) {
            if (pthread_create(&threads_[i], NULL, worker_thread, this) != 0) {
                // 清理已创建的线程
                stop_ = true;
                pthread_cond_broadcast(&cond_);
                
                for (size_t j = 0; j < i; ++j) {
                    pthread_join(threads_[j], NULL);
                }
                
                pthread_mutex_destroy(&mutex_);
                pthread_cond_destroy(&cond_);
                throw std::runtime_error("Failed to create thread");
            }
        }
    }

    // 析构函数
    ~ThreadPool() {
        // 停止所有线程
        pthread_mutex_lock(&mutex_);
        stop_ = true;
        pthread_cond_broadcast(&cond_);  // 唤醒所有等待的线程
        pthread_mutex_unlock(&mutex_);
        
        // 等待所有线程结束
        for (size_t i = 0; i < threads_.size(); ++i) {
            pthread_join(threads_[i], NULL);
        }
        
        // 清理剩余任务
        while (!tasks_.empty()) {
            Task* task = tasks_.front();
            tasks_.pop();
            delete task;
        }
        
        // 销毁同步对象
        pthread_mutex_destroy(&mutex_);
        pthread_cond_destroy(&cond_);
    }

    // 禁止拷贝
    ThreadPool(const ThreadPool&) = delete;
    ThreadPool& operator=(const ThreadPool&) = delete;

    // 提交有返回值的任务
    template<typename Result>
    Result submit(Result (*func)()) {
        ResultTask<Result>* task = new ResultTask<Result>(func);
        
        pthread_mutex_lock(&mutex_);
        tasks_.push(task);
        pthread_cond_signal(&cond_);  // 唤醒一个工作线程
        pthread_mutex_unlock(&mutex_);
        
        Result result = task->get_result();
        delete task;
        return result;
    }

    // 提交无返回值的任务
    void submit(void (*func)()) {
        ResultTask<void>* task = new ResultTask<void>(func);
        
        pthread_mutex_lock(&mutex_);
        tasks_.push(task);
        pthread_cond_signal(&cond_);
        pthread_mutex_unlock(&mutex_);
        
        task->get_result();  // 等待任务完成
        delete task;
    }

    // 动态调整线程数量
    void resize(size_t new_num_threads) {
        if (new_num_threads == num_threads_) return;
        
        pthread_mutex_lock(&mutex_);
        size_t old_num = num_threads_;
        num_threads_ = new_num_threads;
        
        // 增加线程
        if (new_num_threads > old_num) {
            threads_.resize(new_num_threads);
            for (size_t i = old_num; i < new_num_threads; ++i) {
                if (pthread_create(&threads_[i], NULL, worker_thread, this) != 0) {
                    num_threads_ = i;
                    pthread_mutex_unlock(&mutex_);
                    throw std::runtime_error("Failed to resize thread pool");
                }
            }
        }
        pthread_mutex_unlock(&mutex_);
        
        // 减少线程
        if (new_num_threads < old_num) {
            // 唤醒足够的线程让它们退出
            for (size_t i = new_num_threads; i < old_num; ++i) {
                pthread_cond_signal(&cond_);
            }
            
            // 等待多余的线程退出
            for (size_t i = new_num_threads; i < old_num; ++i) {
                pthread_join(threads_[i], NULL);
            }
            
            pthread_mutex_lock(&mutex_);
            threads_.resize(new_num_threads);
            pthread_mutex_unlock(&mutex_);
        }
    }

    // 获取当前线程数量
    size_t thread_count() const {
        return num_threads_;
    }

private:
    // 工作线程函数（静态成员函数作为pthread入口）
    static void* worker_thread(void* arg) {
        ThreadPool* pool = static_cast<ThreadPool*>(arg);
        pool->process_tasks();
        return NULL;
    }

    // 线程处理任务的主循环
    void process_tasks() {
        while (true) {
            pthread_mutex_lock(&mutex_);
            
            // 等待任务或停止信号
            while (!stop_ && tasks_.empty()) {
                pthread_cond_wait(&cond_, &mutex_);
            }
            
            // 检查是否需要退出
            if (stop_ || threads_.size() > num_threads_) {
                pthread_mutex_unlock(&mutex_);
                break;
            }
            
            // 取出任务
            Task* task = tasks_.front();
            tasks_.pop();
            pthread_mutex_unlock(&mutex_);
            
            // 执行任务
            try {
                task->execute();
            } catch (const std::exception& e) {
                // 简单处理异常，实际应用可根据需要扩展
                fprintf(stderr, "Task execution error: %s\n", e.what());
            } catch (...) {
                fprintf(stderr, "Unknown task execution error\n");
            }
        }
    }

    std::vector<pthread_t> threads_;  // 工作线程数组
    std::queue<Task*> tasks_;         // 任务队列
    pthread_mutex_t mutex_;           // 保护任务队列的互斥锁
    pthread_cond_t cond_;             // 条件变量，用于通知线程有新任务
    bool stop_;                       // 线程池停止标志
    size_t num_threads_;              // 当前线程数量
};

#endif // THREAD_POOL_H

使用示例（main.cpp）

#include "thread_pool.h"
#include <iostream>
#include <cstdio>
#include <ctime>
#include <unistd.h>

// 示例任务1：计算平方
int calculate_square(int x) {
    // 模拟耗时操作
    usleep(10000);  // 10毫秒
    return x * x;
}

// 示例任务2：打印消息
void print_message(const char* msg) {
    usleep(5000);   // 5毫秒
    printf("Message: %s\n", msg);
}

// 包装函数，用于适配线程池的函数指针要求
int square_wrapper() {
    static int x = 0;
    int result = calculate_square(x);
    x = (x + 1) % 10;  // 循环计算0-9的平方
    return result;
}

// 打印消息的包装函数
void message_wrapper() {
    static int count = 0;
    char msg[128];
    sprintf(msg, "Task %d completed", count++);
    print_message(msg);
}

int main() {
    try {
        // 创建包含4个线程的线程池
        ThreadPool pool(4);
        printf("Initial thread count: %zu\n", pool.thread_count());
        
        // 提交10个计算平方的任务
        printf("\nCalculating squares:\n");
        for (int i = 0; i < 10; ++i) {
            int result = pool.submit(square_wrapper);
            printf("%d ", result);
        }
        printf("\n");
        
        // 调整线程数量为6
        pool.resize(6);
        printf("\nResized thread count: %zu\n", pool.thread_count());
        
        // 提交一批打印任务
        printf("\nPrinting messages:\n");
        for (int i = 0; i < 8; ++i) {
            pool.submit(message_wrapper);
        }
        
        // 再次调整线程数量为2
        pool.resize(2);
        printf("\nFinal thread count: %zu\n", pool.thread_count());
        
    } catch (const std::exception& e) {
        fprintf(stderr, "Error: %s\n", e.what());
        return 1;
    }
    
    return 0;
}

线程池工作原理

  1. 初始化阶段：

    • 创建指定数量的工作线程
    • 初始化互斥锁和条件变量用于同步
    • 工作线程进入等待状态，等待新任务

  2. 任务提交阶段：

    • 将任务封装成Task对象
    • 加锁后将任务放入任务队列
    • 发送信号唤醒一个等待的工作线程

  3. 任务执行阶段：

    • 工作线程被唤醒，从队列中取出任务
    • 解锁后执行任务
    • 任务完成后，线程回到等待状态

  4. 动态调整阶段：

    • 增加线程：直接创建新的工作线程
    • 减少线程：唤醒多余线程并让它们退出

  5. 销毁阶段：

    • 设置停止标志并唤醒所有线程
    • 等待所有线程完成当前任务并退出
    • 清理剩余任务和同步对象

适用场景

  • 服务器开发：处理大量并发请求（如Web服务器、数据库服务器）
  • 批量数据处理：图像转换、数据分析等可并行的计算任务
  • 异步IO操作：网络请求、文件读写等IO密集型任务
  • 实时系统：需要控制线程数量和资源使用的嵌入式系统

编译与使用

使用GCC编译时需要指定C++03标准并链接pthread库：

g++ -std=c++03 main.cpp -o thread_pool -lpthread

这个实现虽然没有C++11及以上版本的线程池简洁，但在不支持现代C++标准的环境中仍然是一个可靠的多线程任务处理方案。

『 Linux 』线程池与 POSIX 线程的封装编码实现
小侯宝的博客
08-02 1130
这篇文章详细介绍了线程池的概念和实现。文章首先解释了线程池的基本原理，包括资源分配、复用和管理等方面。接着，展示了一个线程池的C++实现，包括线程池类的设计、任务队列的管理、线程同步机制等核心组件。文章还提供了一个简单的任务类和测试代码，用于演示线程池的使用。 此外，文章还讨论了线程的封装技术，展示了如何将POSIX线程封装成一个C++类，使线程的使用更加面向对象和便捷。文章通过代码示例和详细注释，清晰地展示了线程池和线程封装的实现细节，包括构造函数、线程启动、任务处理等关键方法。
C++封装POSIX 线程库（六）线程池
上善若水
05-24 1964
线程池有两个主要组件: 1.threads 2.blocking queue 解决的问题是线程创建与销毁带来的开销和通过线程池实现伪异步 过程类似于简单的生产者消费者问题(详见wiki)Blocking Queue对应用户添加任务CallBack和线程拿任务执行两个操作,因此需要两个条件变量和一个互斥锁如果把用户添加任务比做生产者,线程拿任务比做消费者..那么需要两个条件变量就解决了
C++ 面向对象技术实战：实现基于 POSIX 线程标准封装的线程池
qq_53324833的博客
08-13 918
最后的线程池项目目录结构如下：基于面向对象的方式实现的线程池；以上就是本文的全部内容。
C++ 面向对象技术实战：实现基于 POSIX 线程标准的线程封装并解决生产者消费者问题
qq_53324833的博客
01-20 1035
如上图所示，所谓的生产者和消费者都是一个线程，生产者与消费者之间需要进行交互，生产者生产数据往缓冲区内放，生产一个放一个，消费者则会从仓库里面拿数据，此时这个缓冲区就是一个共享资源。生产者与消费者在进行对缓冲区的访问时，为了使得线程同步所以需要获得锁才可以，获得了锁的线程才能进行访问，访问完之后再释放掉锁等其它线程竞争获取。那为什么还需要条件变量呢？来看这么个情况，如果消费者竞争到了锁，然后进入了缓冲区，但此时缓冲区内并没有数据（这是一个没有意义的操作），是不是就造成了锁资源的浪费？
C++11 std::thread线程库
code_peak
06-25 2505
翻译原文：https://thispointer.com/c11-tutorial/ C++11 线程库介绍 C++11 中新增了多线程 std::thread，相比之前使用较多的是操作系统提供的 POSIX 线程接口，新标准引入了线程库无疑带来了许多便利。 要使用 C++11 多线程，首先 gcc 编译器版本需要大于4.8，并且编译时，需要加上参数 -std=c++11 -lpthread，可见，C++11 的线程是对 POSIX 线程的封装。 C++11 线程创建 在每个 C++ 应用程序中，都有一个默
构建高效线程池模块：C++11多线程实践指南
weixin_42186015的博客
10-24 647
本文还有配套的精品资源，点击获取 简介：线程池模块通过重用线程和维护任务队列来提高并发处理性能和资源利用率。在C++11中， std::thread 等新特性简化了线程池的实现。本模块解释了线程池的工作原理，如何在C++11中实现，以及其优缺点和实际应用。开发者可以利用这些知识在项目中选择和构建适合的线程池，实现高效的任务处理。 1. 线程池高效管理...
C++ std::thread线程类 相关问题、函数总结
zxf347085420的博客
07-19 729
特性说明构造即启动线程在创建时立即开始执行移动语义线程所有权可转移，不可复制必须在线程析构前调用，否则程序终止参数传递默认值传递，引用需用std::ref，大对象用std::move异常隔离线程内异常不会传播到主线程RAII模式推荐使用包装类管理线程生命周期正确使用始终管理线程生命周期（join/detach）谨慎处理共享数据（使用同步原语）避免线程间悬垂引用考虑性能影响和线程创建开销优先使用高级抽象（如std::async）简化代码。
C++ Boost库：线程库 thread 跨平台多线程
超级大洋葱的博客
05-05 4552
文章目录1. Windows、Linus多线程2. thread库简介3. 示例代码 1. Windows、Linus多线程 平台 Windows Linux 创建线程 CreateThread()_beginthreadex() pthread_create() 销毁线程 ExitThread()TerminateThread() pthread_exit()pthread_cancel() 暂停线程 SuspendThread() — 恢复线程 ResumeThread()
【C++ 包裹类 std::thread】探索C++11 std::thread：如何使用它来创建、销毁和管理线程
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-10 2642
探索C++11 std::thread：如何使用它来创建、销毁和管理线程
Tpool: POSIX pthread基于C++的线程池实现简析
Tpool:基于POSIX pthread的C++线程池实现 在现代的软件开发中，性能是衡量软件质量的一个重要因素，尤其是在服务器端程序中，如Web服务器、数据库服务器等，高并发处理能力尤为关键。为了提升应用程序的并发处理...
linux C++ 实现线程池（避免线程创建的耗时）
05-22
2. **pthread库**：在Linux系统中，C++多线程编程通常使用POSIX线程库（pthread），它是跨平台的标准线程API。`pthread_create()`用于创建新的线程，`pthread_join()`用于等待线程结束，`pthread_exit()`用于线程...
C++(C++98、C++03、C++11)实现的线程池.zip
11-27
C++98实现的线程池通常依赖于操作系统级别的API，如POSIX线程库（pthread）或Windows API，来创建和管理线程。在C++98中实现线程池需要手动管理线程的生命周期，包括线程的创建、启动、同步、以及最终的线程销毁。...
C++ 运算符：从基础到高阶的完整指南
正在在摸鱼的博客
08-22 334
运算符重载是C++支持多态性的核心特性之一，允许程序员为自定义类型赋予运算符的语义化操作能力。其本质是通过函数重载机制实现的，编译器会根据操作数类型选择最匹配的运算符函数。+=
C++高频知识点（三十一）
Atticus的博客
08-20 386
本文摘要了5个技术问题： 在1GB物理内存中malloc 2GB可能成功，因现代系统支持虚拟内存； 同名同参函数可通过const重载，编译器能区分const和非const版本； GET与POST区别：GET参数在URL可见有长度限制，POST通过请求体传输更安全； Redis持久化机制：RDB快照恢复快但可能丢数据，AOF日志更安全但文件较大，推荐混合模式； ++i返回自增后引用（高效），i++返回原值副本（需临时对象）。 （字数：149）
C++ STL -4 | vector
电子异术博物馆
08-22 532
介绍C++中std::vector的使用技巧与底层机制。重点包括：1）vector的动态数组特性与基本操作；2）容量管理（size/capacity区别、预分配优化）；3）底层实现（连续存储、扩容机制）；4）特殊用法（swap回收内存、emplace高效构造）；5）vector<bool>的特化实现与陷阱；6）开发注意事项（迭代器失效、性能优化等）。适合有一定基础的开发者掌握vector的进阶特性，提升使用效率与规避常见错误。
c++信奥之vector
最新发布
小前日记
08-23 321
本文介绍了C++标准模板库(STL)的基本概念和常用容器vector的操作方法。STL由容器、算法和迭代器三大组件构成，其中vector是动态数组容器。文章详细讲解了vector的四种创建方法、元素增删改查操作（push_back、erase、insert等）以及常用函数如reverse翻转。通过示例代码展示了如何实现向量的基本操作，包括在指定位置插入元素、删除特定下标元素等。这些操作都通过vector的迭代器（begin、end）来完成，体现了STL模板化编程的灵活性。
CH582、CH592、CH584硬件IIC驱动 OLED显示屏
weald2000的专栏
08-21 841
本文介绍了IIC串行通信协议及其在OLED驱动中的应用。IIC协议采用双线制（SDA/SCL），支持多设备连接，适用于低速外设通信。文章详细说明了IIC总线拓扑设计、地址冲突处理等硬件连接要点，并提供了CH592 MCU的IIC接口配置方法。重点阐述了4Pin IIC驱动OLED屏幕的实现过程，包括SSD1315/SSD1306芯片的地址差异、数据格式和控制字节解析。通过实例代码展示了OLED初始化、像素设置、显示刷新等操作，并提供了常见问题排查指南
C++之二叉树进阶
夏天的阳光吖的博客
08-22 900
​ 在前面的章节中，我们学习过二叉树：数据结构之二叉树 后面学习map和set的特性时，需要先铺垫二叉搜索树，二叉搜索树也是一种树形结构。 对二叉搜索树的特性了解，有助于更好的理解map和set的特性。 有些OJ题使用C语言实现比较麻烦，比如有些地方要返回动态开辟的二维数组，非常麻烦。 这一章中，我们学习二叉搜索树，对二叉树部分进行收尾总结。 ​
C/C++ 常见笔试题与陷阱详解
zxjiaya的博客
08-20 1340
C/C++ 笔试题常见陷阱解析 本文剖析了C/C++笔试中的几个典型陷阱案例：1) (int&)a与(int)a的区别，前者按整型解读浮点数内存，后者进行值转换；2) 构造函数调用次数判定，指针声明不会触发构造；3) 左值函数需返回引用才能赋值；4) cout对char*的特殊处理会输出字符串而非地址；5) 指针交换函数需解引用操作真实值；6) 数组引用语法int (&arr)[N]的合法写法。这些案例揭示了类型转换、内存存储、引用本质等核心知识点，帮助开发者规避常见编码陷阱。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bkspiderx

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值