linux c++线程池

一、基础概念

线程池
- 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池中的线程可以重复使用，避免了频繁创建和销毁线程的开销。
- 在Linux的C++ 中，可以通过系统调用（如pthread库）来实现线程池的功能。

pthread库（POSIX Threads）
- 这是Linux下用于实现多线程编程的标准库。它提供了一系列函数来创建、管理线程，例如pthread_create用于创建新线程，pthread_join用于等待线程结束等。

二、优势

性能提升
- 减少线程创建和销毁的时间开销。创建和销毁线程涉及到系统资源的分配和回收，如栈空间的分配等，这些操作是比较耗时的。线程池中的线程可以被重复利用，对于大量短任务的情况，可以显著提高程序的执行效率。

资源管理
- 便于控制并发线程的数量。如果不加限制地创建线程，可能会导致系统资源耗尽，如内存不足等问题。线程池可以根据系统资源和任务需求预先设定线程数量的上限，确保系统的稳定运行。
任务调度
- 方便对任务进行统一的管理和调度。可以将任务按照一定的顺序（如先来先服务）放入任务队列，线程从队列中获取任务并执行。

三、类型

固定大小线程池
- 线程池中的线程数量是固定的。适用于任务数量相对稳定，并且可以预估线程需求的场景。例如，服务器处理固定数量的并发连接请求。

可伸缩线程池
- 根据任务的数量动态调整线程的数量。当任务数量增加时，可以创建更多的线程来处理任务；当任务数量减少时，可以销毁部分线程以节省资源。这种类型的线程池适用于任务数量波动较大的场景。

四、应用场景

服务器编程
- 在网络服务器中，例如Web服务器需要处理大量的客户端连接请求。使用线程池可以高效地处理这些请求，提高服务器的并发处理能力。

并行计算
- 对于一些可以并行执行的任务，如数据处理中的并行计算部分，可以利用线程池将任务分配给多个线程同时处理，加快计算速度。

五、可能遇到的问题及解决方法

死锁问题
- 原因：
  - 如果线程池中的线程在获取多个资源时顺序不当，可能会导致死锁。例如，线程A先获取资源1再获取资源2，而线程B先获取资源2再获取资源1，当两个线程都获取了其中一个资源并等待另一个资源时就会发生死锁。
  - 任务之间存在循环依赖关系，导致线程在等待其他任务完成时无法继续执行。
- 解决方法：
  - 确保线程获取资源的顺序一致。
  - 对任务进行合理的设计，避免循环依赖关系。可以使用有向无环图（DAG）来表示任务之间的依赖关系，确保不存在环。

线程饥饿问题
- 原因：
  - 如果任务队列中的任务分配不均匀，或者某些高优先级任务总是抢占资源，可能会导致部分线程长时间得不到执行机会。
- 解决方法：
  - 采用公平的任务调度策略，例如轮询地从任务队列中获取任务分配给线程。
  - 合理设置任务的优先级，避免过度偏向高优先级任务。

以下是一个简单的Linux C++ 固定大小线程池示例代码：

#include <iostream>
#include <vector>
#include <queue>
#include <pthread.h>
#include <unistd.h>

// 任务结构体
struct Task {
    void (*function)(void*);
    void* argument;
};

// 线程池类
class ThreadPool {
private:
    std::queue<Task> taskQueue;
    pthread_mutex_t queueMutex;
    pthread_cond_t condition;
    bool stop;
    std::vector<pthread_t> threads;
    int threadCount;

public:
    ThreadPool(int numThreads);
    ~ThreadPool();
    void addTask(void (*function)(void*), void* argument);
};

ThreadPool::ThreadPool(int numThreads) {
    threadCount = numThreads;
    stop = false;
    pthread_mutex_init(&queueMutex, NULL);
    pthread_cond_init(&condition, NULL);

    for (int i = 0; i < numThreads; ++i) {
        pthread_t thread;
        pthread_create(&thread, NULL, [](void* arg) {
            ThreadPool* pool = (ThreadPool*)arg;
            while (true) {
                Task task;
                pthread_mutex_lock(&pool->queueMutex);
                while (pool->taskQueue.empty() &&!pool->stop) {
                    pthread_cond_wait(&pool->condition, &pool->queueMutex);
                }
                if (pool->stop && pool->taskQueue.empty()) {
                    pthread_mutex_unlock(&pool->queueMutex);
                    break;
                }
                task = pool->taskQueue.front();
                pool->taskQueue.pop();
                pthread_mutex_unlock(&pool->queueMutex);
                task.function(task.argument);
            }
        }, this);
        threads.push_back(thread);
    }
}

ThreadPool::~ThreadPool() {
    stop = true;
    pthread_cond_broadcast(&condition);
    for (pthread_t thread : threads) {
        pthread_join(thread, NULL);
    }
    pthread_mutex_destroy(&queueMutex);
    pthread_cond_destroy(&condition);
}

void ThreadPool::addTask(void (*function)(void*), void* argument) {
    Task task;
    task.function = function;
    task.argument = argument;
    pthread_mutex_lock(&queueMutex);
    taskQueue.push(task);
    pthread_cond_signal(&condition);
    pthread_mutex_unlock(&queueMutex);
}

// 示例任务函数
void exampleTask(void* num) {
    int* n = (int*)num;
    std::cout << "Task executed by thread " << pthread_self() << " with number " << *n << std::endl;
    sleep(1);
}

int main() {
    ThreadPool pool(3);
    for (int i = 0; i < 5; ++i) {
        int* num = new int(i);
        pool.addTask(exampleTask, num);
    }
    sleep(10);
    return 0;
}

在这个示例中：