Linux环境下用pthread库制作一个简单的线程池

已于 2023-12-06 11:29:17 修改
阅读量1.3k 收藏 20
点赞数 24
文章标签： c语言 linux 经验分享 ubuntu
于 2023-12-04 20:23:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzzzzz_9/article/details/134791585
版权

何为线程池，线程池有什么作用？

        线程池是一种线程管理的机制，它允许在应用程序中预先创建一组线程，并使用这些线程来执行并发任务。线程池提供了一种优化线程使用和管理的方式，它通过减少线程创建和销毁的开销、限制线程数量以及通过任务队列来调度任务等方式来提高系统的性能和资源利用率。

提高性能：线程池允许并发地执行多个任务，因为预先创建的线程可以立即可用，避免了线程创建和销毁的开销。并且通过合理配置线程池的线程数量，避免了过多的线程竞争，从而提高系统的响应速度和吞吐量。

提高资源利用率：线程池可以限制系统中线程的数量，防止系统因过多的线程而耗尽CPU、内存等资源。通过复用线程，线程池可以更好地管理系统资源，提高资源的利用率。

任务调度与管理：线程池使用任务队列来接收和存储待执行的任务，对任务进行调度和分发给可用的线程。通过任务队列，线程池可以有效地管理任务的执行顺序、优先级以及异常情况的处理。

控制并发度：通过限制线程池中的线程数量，可以控制并发执行的任务数量，避免系统资源被过度占用。这样可以避免系统资源的饱和和过载，提高系统的稳定性。

一般在什么情况下值得使用线程池，什么时候反而不应使用呢？

  1. 需要处理大量并发任务：当应用程序需要同时处理大量的并发任务时，使用线程池可以更好地管理和调度这些任务，提高系统的并发处理能力。
  2. 任务执行时间较长：如果任务的执行时间较长，创建和销毁线程的开销相对较高，使用线程池可以避免频繁的创建和销毁线程，提高效率。
  3. 资源有限：在资源有限的环境下，如服务器端应用，有限的线程资源需要被合理利用。使用线程池可以限制并控制线程的数量，防止资源被过度占用。
  4. 异步任务：线程池可以用于执行异步任务，可以提交任务后立即返回，并通过回调或者Future对象来获取任务的执行结果。 
  5. 任务之间相互依赖：如果任务之间存在较强的依赖关系，需要等待前一个任务完成后才能执行后续任务，使用线程池可能无法满足这种需求，可能需要其他的并发编程模型。
  6. 线程任务执行时间非常短暂：如果任务的执行时间非常短暂，线程池的线程创建和调度开销可能会超过执行任务的时间，反而会降低性能。
  7. 任务需要严格控制执行时机：如果需要严格控制任务的执行时机，如在特定时刻执行任务或者需要精确的任务调度时间，使用线程池可能无法满足这种需求。

让我们来通过代码pthread库制作一个简单的线程池吧

        在这里我先放出头文件：

#ifndef MANAGEMENT_H
#define MANAGEMENT_H
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define THREAD_POOL_SIZE 10

typedef struct {
    void (*function)(void* arg); 
    void* arg;
} ThreadPoolTask;

typedef struct {
    pthread_t threads[THREAD_POOL_SIZE];   // 存储线程ID的数组
    int thread_count;                      // 线程数量
    int task_count;                        // 任务数量
    int shutdown;                          // 标志线程池是否关闭
    ThreadPoolTask* tasks;                 // 存储任务的数组指针
    pthread_mutex_t mutex;                 // 互斥锁，用于对线程池进行同步
    pthread_cond_t condition;              // 条件变量，用于线程间的等待和唤醒
} ThreadPool;

void threadPoolInit(ThreadPool* pool);
int threadPoolDestroy(ThreadPool* pool);
void threadPoolAddTask(ThreadPool* pool, void (*function)(void* arg), void* arg);
void* threadPoolThread(void* threadData);
void taskFunction(void* arg);
void threadPoolAdjustThread(ThreadPool* pool, int numThreads, int operation);
#endif

THREAD_POOL_SIZE是线程的总数量，就是创建线程池时，一共池子里会有多少线程。

ThreadPoolTask 结构体：

  • void (function)(void arg)：这是一个函数指针，指向一个以 void* 类型的参数为输入，没有返回值的函数。该函数指针用于执行具体的任务。
  • void* arg：这是一个指针类型的参数，用于传递给任务函数的实际参数。任务函数在执行时可以通过这个参数访问和操作特定数据。 ThreadPoolTask 结构体用于表示线程池中的任务，并且包含了任务函数指针和参数，以便在执行任务时传递给任务函数进行执行。

ThreadPool 结构体：

  • pthread_t threads[THREAD_POOL_SIZE]：这是一个数组，用于存储线程ID，大小为 THREAD_POOL_SIZE。在线程池初始化时，会创建一定数量的线程并将其ID存储在这个数组中。这些线程将负责执行任务。
  • int thread_count：表示线程池中当前的线程数量。
  • int task_count：表示线程池中当前的任务数量。
  • int shutdown：表示线程池是否关闭的标志，当该标志位为非零值时，线程池将不再接受新的任务。
  • ThreadPoolTask* tasks：这是一个指针类型的成员，指向存储任务的数组。实际上，这个指针指向了一块内存区域，其中存储了多个 ThreadPoolTask 结构体的实例。
  • pthread_mutex_t mutex：互斥锁，用于对线程池进行同步。线程在对线程池中的数据进行修改时，需要先获得互斥锁，以保证线程安全性。
  • pthread_cond_t condition：条件变量，用于线程间的等待和唤醒。当线程池中任务为空时，线程将等待条件变量的触发，直到有新任务被添加进来后被唤醒。 ThreadPool 结构体用于管理线程池的状态，并提供线程间的同步和协调机制。它包含了线程和任务的数量，以及用于同步的互斥锁和条件变量。 ThreadPoolTask 结构体则用于封装任务函数和参数，以便在线程池的线程中传递和执行任务。通过这两个结构体的组合，线程池能够有效地管理和调度任务的执行。

下面是C文件

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "management.h"

// 初始化线程池
void threadPoolInit(ThreadPool* pool) {
    pool->thread_count = 0; // 初始化线程计数为0
    pool->task_count = 0; // 初始化任务计数为0
    pool->shutdown = 0; // 初始化关闭标志为0，表示线程池未关闭
    pool->tasks = (ThreadPoolTask*)malloc(sizeof(ThreadPoolTask) * THREAD_POOL_SIZE); // 为任务数组分配内存空间，大小为线程池大小
    // 初始化互斥锁和条件变量
    pthread_mutex_init(&(pool->mutex), NULL);
    pthread_cond_init(&(pool->condition), NULL);
    int i;
    for (i = 0; i < THREAD_POOL_SIZE; i++) {
        // 创建线程并增加线程计数
        pthread_create(&(pool->threads[i]), NULL, threadPoolThread, (void*)pool);
        pool->thread_count++;
    }
}

int threadPoolDestroy(ThreadPool* pool) {
    if (pool == NULL) {
        return 1; // 确保线程池指针不为空
    }
    
    if (pool->shutdown) {
        return 1; // 如果关闭标志为1，直接返回，避免重复销毁线程池
    }
    
    // 设置关闭标志为1，表示线程池将要关闭
    pool->shutdown = 1;
    
    // 唤醒所有等待在条件变量上的线程
    pthread_cond_broadcast(&(pool->condition));
    
    int i;
    for (i = 0; i < pool->thread_count; i++) {
        // 等待所有线程结束
        pthread_join(pool->threads[i], NULL);
    }
    
    // 释放任务数组内存
    if (pool->tasks != NULL) {
        free(pool->tasks); 
    }
    
    // 销毁互斥锁
    pthread_mutex_destroy(&(pool->mutex)); 
    
    // 销毁条件变量
    pthread_cond_destroy(&(pool->condition)); 
    
    return 0;
}

// 添加任务到线程池
void threadPoolAddTask(ThreadPool* pool, void (*function)(void* arg), void* arg) {
    pthread_mutex_lock(&(pool->mutex)); // 加锁互斥锁
    // 获取任务位置
    ThreadPoolTask* task = &(pool->tasks[pool->task_count]);
    task->function = function;
    task->arg = arg;
    pool->task_count++; // 增加任务计数
    pthread_cond_signal(&(pool->condition)); // 唤醒等待的线程
    pthread_mutex_unlock(&(pool->mutex)); // 解锁互斥锁
}

// 线程函数，用于执行任务
void* threadPoolThread(void* threadData) {
    ThreadPool* pool = (ThreadPool*)threadData;
    while (1) {
        pthread_mutex_lock(&(pool->mutex)); // 加锁互斥锁
        // 等待任务或关闭标志
        while (pool->task_count == 0 && !pool->shutdown) {
            pthread_cond_wait(&(pool->condition), &(pool->mutex)); // 等待条件变量唤醒
        }
        // 如果关闭标志为1，退出线程
        if (pool->shutdown) {
            pthread_mutex_unlock(&(pool->mutex)); // 解锁互斥锁
            pthread_exit(NULL); // 退出线程
        }
        // 获取任务并减少任务计数，解锁互斥锁
        ThreadPoolTask task = pool->tasks[pool->task_count - 1];
        pool->task_count--;
        pthread_mutex_unlock(&(pool->mutex)); // 解锁互斥锁
        // 执行任务函数
        (*(task.function))(task.arg);
    }
    pthread_exit(NULL);
}

void threadPoolAdjustThread(ThreadPool* pool, int numThreads, int operation) {
    if (pool == NULL || numThreads == 0) {
        return;
    }
    
    pthread_mutex_lock(&(pool->mutex)); // 加锁互斥锁
    
    if (operation == 1) { // 增加线程数量
        // 计算要增加的线程数量
        int newThreadCount = pool->thread_count + numThreads;
        if (newThreadCount > THREAD_POOL_SIZE) {
            newThreadCount = THREAD_POOL_SIZE;
        }
        
        int i;
        for (i = pool->thread_count; i < newThreadCount; i++) {
            // 创建线程并增加线程计数
            pthread_create(&(pool->threads[i]), NULL, threadPoolThread, (void*)pool);
            pool->thread_count++;
        }
    } else if (operation == 0) { // 减少线程数量
        // 计算要减少的线程数量
        int reducedThreadCount = pool->thread_count - numThreads;
        if (reducedThreadCount <= 0) {
            reducedThreadCount = 0;
        }
        
        int i;
        for (i = pool->thread_count - 1; i >= reducedThreadCount; i--) {
            // 取消线程并减少线程计数
            pthread_cancel(pool->threads[i]);
            pthread_join(pool->threads[i], NULL);
            pool->thread_count--;
        }
    }
    
    pthread_mutex_unlock(&(pool->mutex)); // 解锁互斥锁
}

threadPoolInit(ThreadPool* pool)

  • 功能：初始化线程池。
  • 实现方法：
    • 设置线程计数、任务计数和关闭标志为零。
    • 分配内存空间以存储任务数组，大小为线程池大小。
    • 初始化互斥锁和条件变量。
    • 创建指定数量的线程，并增加线程计数。

int threadPoolDestroy(ThreadPool* pool)

  • 功能：销毁线程池。
  • 实现方法：
    • 检查线程池是否为NULL，如果是则返回1。
    • 检查关闭标志，如果为1则表示线程池已经关闭，直接返回1以避免重复销毁线程池。
    • 设置关闭标志为1以表示线程池将要关闭。
    • 唤醒所有等待在条件变量上的线程。
    • 循环等待所有线程结束。
    • 释放任务数组的内存。
    • 销毁互斥锁和条件变量。
    • 返回0表示销毁成功。

void threadPoolAddTask(ThreadPool* pool, void (*function)(void* arg), void* arg)

  • 功能：将任务添加到线程池。
  • 实现方法：
    • 加锁互斥锁以保护共享资源。
    • 获取可用的任务位置。
    • 将任务函数和参数存储在任务数组中。
    • 增加任务计数。
    • 唤醒等待的线程。
    • 解锁互斥锁。

void* threadPoolThread(void* threadData)

  • 功能：线程函数，用于执行任务。
  • 实现方法：
    • 将线程数据转换为线程池类型。
    • 循环执行以下逻辑：
      • 加锁互斥锁。
      • 在任务计数为零且关闭标志为否时等待条件变量唤醒。
      • 如果关闭标志为1，表示线程池将要关闭，解锁互斥锁并退出线程。
      • 获取任务，并减少任务计数，解锁互斥锁。
      • 执行任务函数。
    • 退出线程。

void threadPoolAdjustThread(ThreadPool* pool, int numThreads, int operation)

  • 功能：调整线程数量。
  • 实现方法：
    • 检查线程池和要调整的线程数量是否为NULL或零，如果是则返回。
    • 加锁互斥锁。
    • 如果操作为1（增加线程数量）：
      • 计算要增加的线程数量，并确保不超过线程池大小。
      • 循环从线程计数开始增加线程直到新线程计数达到要增加的线程数量。
    • 如果操作为0（减少线程数量）：
      • 计算要减少的线程数量，并确保不小于零。
      • 循环从线程计数减一开始取消线程直到线程计数达到要减少的线程数量。
    • 解锁互斥锁。 每个函数都有特定的功能，利用互斥锁和条件变量来保证线程安全性。线程池提供了任务的添加、执行和调整线程数量的功能。

范例

        下面我写了一个范例，例如用线程池完成一份文件的读取的任务指针函数，到时候我们再主函数里面使用以上函数调用的时候以这个指针函数作为参数来实现对文件的读取。

#ifndef EXAMPLE_H
#define EXAMPLE_H
// 包含必要的头文件
#include <stdio.h>
#include <sys/stat.h>
#include "management.h"
// 定义常量、宏和结构体等
#define BUFFER_SIZE 1024

typedef struct {
    const char *file_name;
    unsigned char *array;
    int start_index;
    int size;
} ThreadArgs;

void *read_file(void *arg);
int getFileSize(const char *filename);

#endif /* EXAMPLE_H */
#include "example.h"

void *read_file(void *arg) {
    ThreadArgs *args = (ThreadArgs *)arg;
    const char *file_name = args->file_name;
    unsigned char *array = args->array;
    int start_index = args->start_index;
    int size = args->size;
    // 打开文件
    FILE *file = fopen(file_name, "r");
    if (file == NULL) {
        printf("文件不存在\n");
        pthread_exit(NULL);
    }
    // 定位文件指针到指定位置
    fseek(file, start_index, SEEK_SET);
    // 读取文件内容
    int bytes_read = fread(array + start_index, 1, size, file);
    if (bytes_read == 0) {
        printf("文件读取出错\n");
    }
    // 关闭文件
    fclose(file);
    pthread_exit(NULL);
}

int getFileSize(const char *filename) {
    struct stat st;
    if (stat(filename, &st) == 0) {
        return st.st_size;
    }
    return -1; // 文件不存在或获取失败
}
主函数
#include "management.h"
#include "example.h"
#include "string.h"

int main()
{
    //初始化线程池
    ThreadPool pool;
    threadPoolInit(&pool);
    
    //文件名称
    const char *file_name = "/home/gec/HDD_STORAGE/Multiprocessing_RW/ztext.txt";
    //给读取文件大小
    int file_size = getFileSize(file_name);
    if(file_size != -1) 
    {
        printf("文件大小：%d 字节\n", file_size);
    } else 
    {
        printf("获取文件大小失败\n");
    }
    unsigned char *array = (unsigned char *)malloc(file_size);
    if(array == NULL)
    {
        perror("数组空间创建失败");
        exit(1);
    }
    memset(array,0,sizeof(array));
    //给每个线程分配任务量
    int thread_size = file_size / THREAD_POOL_SIZE;
    int remainder = file_size % THREAD_POOL_SIZE;
    //给每个线程的arg参数配置
    ThreadArgs thread_args[THREAD_POOL_SIZE];

    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        thread_args[i].file_name = file_name;
        thread_args[i].array = array;
        thread_args[i].start_index = i * thread_size;
        thread_args[i].size = thread_size + (i == THREAD_POOL_SIZE - 1 ? remainder : 0);
        //pthread_create(&pool.threads[i], NULL, read_file, (void *)&thread_args[i]);
        threadPoolAddTask(&pool, (void *)read_file, &thread_args[i]);
    }
    // 等待所有线程完成
    // for (int i = 0; i < THREAD_POOL_SIZE; i++) { 
    //     pthread_join(pool.threads[i], NULL);
    // }
    // 打印结果
    sleep(1);
    for (int i = 0; i < file_size; i++) {
        printf("%c", array[i]);
    }
    printf("\n");
    // 释放内存
    free(array);
    threadPoolDestroy(&pool); // 销毁线程池
    return 0;
}



// // 示例任务函数
// void taskFunction(void* arg) {
//     int taskNumber = *(int*)arg;
//     printf("正在执行任务编号：%d\n", taskNumber);
// }

// int main() {
//     ThreadPool pool;
//     threadPoolInit(&pool); // 初始化线程池
//     int i;
//     for (i = 0; i < 10; i++) 
//     {
//         int* arg = malloc(sizeof(int));
//         *arg = i;
//         threadPoolAddTask(&pool, taskFunction, arg); // 添加任务到线程池
//     }
//     sleep(2); // 暂停2秒
//     threadPoolDestroy(&pool); // 销毁线程池
//     return 0;
// }

        只要做好每个线程都要读取文件大小的分配就好啦，然后再把参数传递到thread_args结构体内，就可以继续传递到任务函数内，用来分配和规划每个任务要干什么。

结果

        这是要读取的范本。

        文件读取成功。

编译脚本

        最后在这里再顺便给一个shell脚本方便大家编译，里面的文件名字自己改动下就好了。


echo "删除原有demo..."
rm test
echo "编译中..."
gcc management.c main.c example.c -o test -pthread
# 检查编译是否成功
if [ $? -eq 0 ]; then
    echo "编译成功"
    # 执行命令
    echo "运行demo..."
    start=$(date +%s)   # 记录开始时间
    ./test
    # 检查命令是否执行成功
    if [ $? -eq 0 ]; then
        end=$(date +%s)     # 记录结束时间
        diff=$(( $end - $start ))  # 计算时间差
        echo "运行成功，累计花费时间： $diff 秒"
    else
        echo "命令执行失败"
        exit 1
    fi
else
    echo "编译失败"
    exit 1
fi
# 完成
echo "完成"

        编译。

./test

        本期分享就到这里，我们共同成长、相互学习，无论是分享自己的经验还是倾听他人的建议，都能让我们更加成熟和专业。让我们一起在这个充满活力的社区中共同进步！

呱呱青蛙呱呱
关注
【专栏必读】王道考研408操作系统+Linux系统编程万字笔记、题目题型总结、注意事项、目录导航和思维导图
快乐江湖的博客
10-27 2万+
王道408考研操作系统)第一章计算机系统概述-第一节1、2：操作系统概念、概念和特征1：理解fork的作用prinf("还没有执行fork函数的本进程为：%d\n" , getpid());//其返回值是pid类型的 sleep(1);if(ret > 0) //父进程返回的是子进程ID {printf("我是父进程，我的id是：%d,我的孩子id是%d\n" , getpid() , ret);sleep(1);} } else if(ret == 0) //子进程fork返回值是0 {.........
基于pthread的线程池，C++实现
luson_xing的专栏
01-10 3048
最近项目需要用到线程池，以前没接触过，断断续续学了两三个星期吧 先在网上找了一个用C实现的，例子挺多，不过我只看了一个 http://www.cnblogs.com/newth/archive/2012/05/09/2492459.html 我觉得写得比较简洁易懂 项目是C++写的，用的ACE框架，而且系统不算小，如果直接用C的话可能会破坏系统原有的封装和扩展性 可能会用ACE的ACE_
Linux pthread 线程池实现
aihongzang7880的博客
05-16 252
　　基于pthread封装了一个简易的ThreadPool,具有以下特性： 　　1.具有优先级的任务队列 　　2.线程池大小可以二次调整，增加线程或者删除空闲线程 　　3.任务两种重写方式，重写run或者使用函数回调 首先是任务类的声明 class Task{ public: string taskName; public: Task(){...
linux多线程
最新发布
dzguoxingyu的博客
09-30 934
两个线程分别对共享变量进行 10000 次递增操作，在每次递增操作之前，线程会对互斥锁进行加锁，在递增操作结束后，线程会对互斥锁进行解锁。当一个线程获取互斥锁时，互斥锁被锁定，其他线程无法获取该互斥锁，直到持有互斥锁的线程释放它。总之，线程退出是多线程编程中的一个重要概念，需要正确地处理线程退出的方式和影响，以确保程序的正确性和稳定性。通过合理地使用多线程，可以提高程序的并发性和性能。在多线程编程中，线程同步是非常重要的概念，主要用于协调多个线程对共享资源的访问，以避免数据不一致、竞争条件和其他并发问题。
Linux pthread 实现线程池学习
chengwang2012的博客
12-01 190
C++ 线程池
线程池精讲（pthread pool）
qq_38769551的博客
09-25 1328
线程池也是多线程的处理方式。是将“生产者”线程提出任务添加到“任务队列”，然后一些线程自动完成“任务队列”上的任务。 多线程编程，创建一个线程，指定去完成某一个任务，等待线程的退出。虽然能够满足编程需求，但是当我们需要创建大量的线程的时候， 在创建过程以及销毁线程的过程中可能会消耗大量的CPU.增加很大开销。 如： 文件夹的copy WEB服务器的响应。 。。。。 。。。。 线程池就是用来解决类似于这样的一个问题的，可以降低频繁地创建和销毁线程所带来地开销。 线程池技术思路： 一般
【操作系统-线程池】Pthread 线程池的设计及实现
MaxwellWong
05-25 1170
Lab Week 15 实验报告 实验内容：设计实现一个线程池 (Thread Pool) 使用 Pthread API 管理线程。 利用回调函数作为线程的启动函数。 采用 pthread 信号量解决线程池分配的互斥问题。 讨论上述方案的技术可行性，尝试写一个设计报告。 在一个源代码文件内实现编码、完成编译、运行和用例测试。 I.线程池 线程池的提出，主要是为了解决： （1）频繁地为某一任务创建和销毁线程所引起的系统资源耗费问题； （2）无限制地为并发请求创建线程且系统对线程数量没有限制而引起的系统资源
Linux中的线程
zsffzb的博客
11-04 1746
1.线程的基本概念 2.线程和进程的区别 *线程的同步 线程的调度 线程的通信编程思想之多线程与多进程(1)——以操作系统的角度述说线程与进程_阳光日志-CSDN博客_多线程和多进程编程线程是什么？要理解这个概念，须要先了解一下操作系统的一些相关概念。大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制
linux.9 Linux多线程
Pinksatrfish的博客
03-12 660
文章目录1.Linux线程概念1.1 什么是线程1.2 线程的优缺点1.3 Linux进程和线程2.Linux线程控制2.1 创建线程2.2 线程等待 1.Linux线程概念 1.1 什么是线程 在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”。一切进程至少都有一个执行线程。线程在进程内部运行，本质是在进程地址空间内运行。在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化。透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合
嵌入式初入门——一个项目了解Linux下文件I/O，网络socket编程，多进程，多线程，多路复用（二）
qq_43416810的博客
03-29 363
多进程 上节提到了accpet()函数处理客户端连接时，当有客户端连接时，函数会返回。那么问题来了，这样作为一个服务器就只能给一个客户端服务了，显然这样的服务器就只能拿来自己玩了。那么怎么处理这个多并发问题呢？ 首先可以先用多进程实现，在accept返回后创建一个子进程负责和客户端通信，父进程继续执行accpet()。 进程ID 进程：正在运行的程序及其占用的资源(CPU、内存、系统资源等)叫做进...
Linux/UNIX系统编程手册gg
weixin_45454852的博客
05-20 2083
第1章 历史和标准 第2章 基本概念 第3章 系统编程概念 第4章 文件I/O
Pthread Pool:使用Pthreads实现的轻量级线程池-开源
04-25
Pthread池是一种轻量级，高效的线程池，完全使用Pthreads API实现。
linux C++ 实现线程池（避免线程创建的耗时）
05-22
linux下c++写的线程池，可以了解pthread_cond_timewait和pthread_detach的用法，自定义最大使用的线程数量，线程退出线程池的超时时间，任务优先级处理。
Linux平台PThreads库多线程编程笔记汇总
01-08
Linux平台PThreads库多线程编程笔记汇总，总结了linux下多线程编程
基于pthread实现的简单线程池模型
FintechBoy的博客
02-10 296
基于pthread实现的简单线程池模型，可实现线程池的创建、运行、终止、释放等操作。其主要API如下： // 创建线程池 int QtpThreadPoolCreate(struct QtpThreadPool** pool, int threadCnt); // 线程池销毁操作 int QtpThreadPoolDestroy(QtpThreadPool* pool); // 线程池任务调...
Linux下调用pthread库实现简单线程池
jiexuan357的专栏
03-10 532
[c-sharp] view plaincopy #include    #include    #include    #include    #include    #include    void * routine(void * arg);   int pool_add_job(void *(*process)(void * arg),void 
c语言+pthread实现线程池
lazy_x的博客
10-24 3923
文章目录1.线程池原理2.项目结构项目源代码tpool.htpool.cdemo.c线程池完整源码见 1.线程池原理 线程池(thread pool)技术是指能够保证所创建的任一线程都处于繁忙状态，而不需要频繁地为了某一任务而创建和销毁线程，因为系统在创建和销毁线程时所耗费的cpu资源很大。如果任务很多，频率很高，为了单一一个任务而起线程而后销线程，那么这种情况效率相当低下的。线程池技术就是用于解决这样一种应用场景而应运而生的。 pthread线程池实现原理，首先创建多个线程组成线程池，其中每个线程都运行一
linux pthread 线程池,基于pthread的线程池，C++实现
weixin_42508905的博客
05-13 117
然后是比较关键的MyThreadPool类MyThreadPool.h#ifndef MYTHREADPOOL_H_#define MYTHREADPOOL_H_#include "MyWorkThread.h"#include "BaseJob.h"#include #include #include #include #include using namespace std;class MyT...
使用pthread模拟一个简单线程池
wxliu1989的专栏
07-17 463
实现： 1.在一个线程池内初始化n个线程，每个线程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值