线程池详解及完整代码实现

已于 2022-09-10 17:12:47 修改
阅读量1.1k 收藏 2
点赞数 3
分类专栏： 高性能组件 文章标签： c语言 java 数据库
于 2022-09-10 17:09:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46935110/article/details/126795806
版权

引言

在Reactor （One eventLoop per thread）模型中，一次时间循环可以处理若干个事件，但是这些事件是串行处理的，一个任务若是执行时间过长，会延迟其他任务的处理，在客户端看来就是响应变慢了。线程池就是处理这种耗时场景的方案之一。
在这里插入图片描述

一、什么是线程池及作用

为了避免线程的频繁创建和销毁，提前准备好一定数量的线程，并管理起来，有任务就分配一个线程去执行，任务执行结束，不是销毁线程，而是放回到线程池，待下次有任务来继续执行。

作用：

  1. 实现了线程的复用
  2. 减少了线程创建和销毁的开销
  3. 减少多个任务（不是一个任务）的执行时间

二、线程池的应用场景

  • 某类任务比较耗时，影响线程执行其他任务；
  • 需要异步的执行某类任务；

三、线程池的接口设计

线程池是一个典型的生产者消费模型。有生产者、队列、消费者（线程池），其中队列用于解耦。

  • 线程池的创建（线程数量和队列大小）
  • 线程池的销毁（线程退出标志和通知所有线程）
  • 添加任务（封装任务、入队、通知线程执行）
  • 任务调度（mutex、condition）
3.1 线程数量如何确定（经验值）

根据耗时任务的类型，可以将任务分为：

  • IO密集型，线程数量为： 2*n + 2（n为CPU核心数）
  • CPU密集型 ，线程数量为：CPU核心数

四、线程池在Redis、Nginx中的应用

4.1 Redis中的线程池

Redis是内存数据库，读写数据嘎嘎快。线程池主要用在，读写 io 处理以及数据包解析、压缩部分。
在这里插入图片描述

4.2 Nginx中的线程池

Nginx线程池模型，主线程将任务加入任务队列，线程池取任务执行，执行完任务将结果存入完成消息队列，通知主线程获取任务执行结果。
在这里插入图片描述
Nginx做静态代理时，作用的位置如下：在这里插入图片描述

五、完整代码示例

5.1 thread_pool.h
#ifndef _THREAD_POOL_H 
#define _THREAD_POOL_H

typedef struct thread_pool_t thread_pool_t;
typedef void (*handler_pt) (void *);

thread_pool_t *thread_pool_create(int thrd_count, int queue_size);

int thread_pool_post(thread_pool_t *pool, handler_pt func, void *arg);

int thread_pool_destroy(thread_pool_t *pool);

int wait_all_done(thread_pool_t *pool);

#endif
5.2 thread_pool.h
#include <pthread.h>
#include <stdint.h>
#include <stddef.h>
#include <stdlib.h>
#include "thrd_pool.h"

typedef struct task_t {
    handler_pt func;
    void * arg;
} task_t;

typedef struct task_queue_t {
    uint32_t head;
    uint32_t tail;
    uint32_t count;
    task_t *queue;
} task_queue_t;

struct thread_pool_t {
    pthread_mutex_t mutex;
    pthread_cond_t condition;
    pthread_t *threads;
    task_queue_t task_queue;

    int closed;
    int started; // 当前运行的线程数

    int thrd_count;
    int queue_size;
};

static void * thread_worker(void *thrd_pool);
static void thread_pool_free(thread_pool_t *pool);

thread_pool_t *
thread_pool_create(int thrd_count, int queue_size) {
    thread_pool_t *pool;

    if (thrd_count <= 0 || queue_size <= 0) {
        return NULL;
    }

    pool = (thread_pool_t*) malloc(sizeof(*pool));
    if (pool == NULL) {
        return NULL;
    }

    pool->thrd_count = 0;
    pool->queue_size = queue_size;
    pool->task_queue.head = 0;
    pool->task_queue.tail = 0;
    pool->task_queue.count = 0;

    pool->started = pool->closed = 0;

    pool->task_queue.queue = (task_t*)malloc(sizeof(task_t)*queue_size);
    if (pool->task_queue.queue == NULL) {
        // TODO: free pool
        return NULL;
    }

    pool->threads = (pthread_t*) malloc(sizeof(pthread_t) * thrd_count);
    if (pool->threads == NULL) {
        // TODO: free pool
        return NULL;
    }

    int i = 0;
    for (; i < thrd_count; i++) {
        if (pthread_create(&(pool->threads[i]), NULL, thread_worker, (void*)pool) != 0) {
            // TODO: free pool
            return NULL;
        }
        pool->thrd_count++;
        pool->started++;
    }
    return pool;
}

int
thread_pool_post(thread_pool_t *pool, handler_pt func, void *arg) {
    if (pool == NULL || func == NULL) {
        return -1;
    }

    task_queue_t *task_queue = &(pool->task_queue);

    if (pthread_mutex_lock(&(pool->mutex)) != 0) {
        return -2;
    }

    if (pool->closed) {
        pthread_mutex_unlock(&(pool->mutex));
        return -3;
    }

    if (task_queue->count == pool->queue_size) {
        pthread_mutex_unlock(&(pool->mutex));
        return -4;
    }

    task_queue->queue[task_queue->tail].func = func;
    task_queue->queue[task_queue->tail].arg = arg;
    task_queue->tail = (task_queue->tail + 1) % pool->queue_size;
    task_queue->count++;

    if (pthread_cond_signal(&(pool->condition)) != 0) {
        pthread_mutex_unlock(&(pool->mutex));
        return -5;
    }
    pthread_mutex_unlock(&(pool->mutex));
    return 0;
}

static void 
thread_pool_free(thread_pool_t *pool) {
    if (pool == NULL || pool->started > 0) {
        return;
    }

    if (pool->threads) {
        free(pool->threads);
        pool->threads = NULL;

        pthread_mutex_lock(&(pool->mutex));
        pthread_mutex_destroy(&pool->mutex);
        pthread_cond_destroy(&pool->condition);
    }

    if (pool->task_queue.queue) {
        free(pool->task_queue.queue);
        pool->task_queue.queue = NULL;
    }
    free(pool);
}

int
wait_all_done(thread_pool_t *pool) {
    int i, ret=0;
    for (i=0; i < pool->thrd_count; i++) {
        if (pthread_join(pool->threads[i], NULL) != 0) {
            ret=1;
        }
    }
    return ret;
}

int
thread_pool_destroy(thread_pool_t *pool) {
    if (pool == NULL) {
        return -1;
    }

    if (pthread_mutex_lock(&(pool->mutex)) != 0) {
        return -2;
    }

    if (pool->closed) {
        thread_pool_free(pool);
        return -3;
    }

    pool->closed = 1;

    if (pthread_cond_broadcast(&(pool->condition)) != 0 || 
            pthread_mutex_unlock(&(pool->mutex)) != 0) {
        thread_pool_free(pool);
        return -4;
    }

    wait_all_done(pool);

    thread_pool_free(pool);
    return 0;
}

static void *
thread_worker(void *thrd_pool) {
    thread_pool_t *pool = (thread_pool_t*)thrd_pool;
    task_queue_t *que;
    task_t task;
    for (;;) {
        pthread_mutex_lock(&(pool->mutex));
        que = &pool->task_queue;
        // 虚假唤醒   linux  pthread_cond_signal
        // linux 可能被信号唤醒
        // 业务逻辑不严谨，被其他线程抢了该任务
        while (que->count == 0 && pool->closed == 0) {
            // pthread_mutex_unlock(&(pool->mutex))
            // 阻塞在 condition
            // ===================================
            // 解除阻塞
            // pthread_mutex_lock(&(pool->mutex));
            pthread_cond_wait(&(pool->condition), &(pool->mutex));
        }
        if (pool->closed == 1) break;
        task = que->queue[que->head];
        que->head = (que->head + 1) % pool->queue_size;
        que->count--;
        pthread_mutex_unlock(&(pool->mutex));
        (*(task.func))(task.arg);
    }
    pool->started--;
    pthread_mutex_unlock(&(pool->mutex));
    pthread_exit(NULL);
    return NULL;
}
5.2 main.c

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

#include "thrd_pool.h"

int nums = 0;
int done = 0;

pthread_mutex_t lock;

void do_task(void *arg) {
    usleep(10000);
    pthread_mutex_lock(&lock);
    done++;
    printf("doing %d task\n", done);
    pthread_mutex_unlock(&lock);
}

int main(int argc, char **argv) {
    int threads = 8;
    int queue_size = 256;

    if (argc == 2) {
        threads = atoi(argv[1]);
        if (threads <= 0) {
            printf("threads number error: %d\n", threads);
            return 1;
        }
    } else if (argc > 2) {
        threads = atoi(argv[1]);
        queue_size = atoi(argv[1]);
        if (threads <= 0 || queue_size <= 0) {
            printf("threads number or queue size error: %d,%d\n", threads, queue_size);
            return 1;
        }
    }

    thread_pool_t *pool = thread_pool_create(threads, queue_size);
    if (pool == NULL) {
        printf("thread pool create error!\n");
        return 1;
    }

    while (thread_pool_post(pool, &do_task, NULL) == 0) {
        pthread_mutex_lock(&lock);
        nums++;
        pthread_mutex_unlock(&lock);
    }

    printf("add %d tasks\n", nums);
    
    wait_all_done(pool);

    printf("did %d tasks\n", done);
    thread_pool_destroy(pool);
    return 0;
}

文章参考于<零声教育>的C/C++linux服务期高级架构

基层搬砖的Panda
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 线程池ExecutorService详解及实例代码
09-01
ExecutorService是Java中实现线程池功能的接口，它扩展了Executor接口。Executor接口只有一个execute()方法，用于执行Runnable任务。ExecutorService则提供了更丰富的操作，如shutdown()用于停止接收新任务并等待已...
Java线程池的拒绝策略实现详解
08-25
Java线程池的拒绝策略实现详解 Java线程池的拒绝策略是指当线程池中的线程数量达到最大值时，如何处理新的任务提交的策略。这个策略是由RejectedExecutionHandler接口定义的，提供了四种默认的拒绝策略：...
线程池概念以及代码实现
2201_75352618的博客
08-28 153
线程池其实也是一种生产者消费者模型。何为线程池，其实就是在程序运行期间提前申请一批线程在自己的栈中等待任务的到来。将任务投入到线程池中，在线程池中让其中一个线程完成任务。为了让线程池中不让线程闲置着，一般可能会有多个执行流向同一个线程池发送任务，那么就必须需要一个缓冲区来存放任务，提高效率。提前申请一批线程当消费者，对这批线程进行封装，我们就叫做线程池。
线程池实现
mzpqq的博客
04-16 1718
这里写目录标题1.线程池1.1定义：1.2线程池的优点1.3线程池的使用 传统线程的缺点： 1.每次都需要创建和消耗线程，是需要消耗系统资源的 2.线程没有任务管理的功能，当任务量比较大的时候没有任务队列对任务进行管理或者是拒绝任务 1.线程池 1.1定义： 线程池就是使用池化技术管理线程和使用线程的一种机制 1.2线程池的优点 1.利用线程池可以复用线程，控制最大并发数（避免了频繁创建和消耗线程池所带来的性能消耗） 2.实现任务缓存和任务拒绝机制 3.实现延迟任务执行 1.3线程池的使用 两种实现方式 1
线程池原理及代码实现
最新发布
control_0317的博客
06-03 639
为什么会有线程池，到底解决了什么问题?减少线程的创建与销毁（线程的角度）异步解耦的作用（设计的角度）
详述Java线程池实现原理
养歌的博客
01-06 2267
线程池是什么 线程池就是创建若干个可执行的线程放入一个池（容器）中，有任务需要处理时，会提交到线程池中的任务队列，处理完之后线程并不会被销毁，而是仍然在线程池中等待下一个任务。 使用线程池有什么好处 降低资源消耗：通过重复利用现有的线程来执行任务，避免多次创建和销毁线程 提高响应速度：因为省去了创建线程这个步骤，所以在拿到任务时，可以立刻开始执行 提供附加功能：线程池的可拓展性使得我们可以自己加入新的功能，比如说定时、延时来执行某些线程 提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统
线程池的介绍和代码实现
m0_61016568的博客
09-23 229
在线程池之前我们应该已经接触了一些"池"，如字符串常量池等等，这些“池”的原理其实都差不多，都是为了提高效率提前开辟一块空间存储所需要的东西，需要用直接拿取即可，不需要另外创建，线程池也是一个道理。相比于进程的创建和销毁，线程的创建和销毁已经很快了，但是如果大量线程频繁创建和销毁，这样的开销依旧是很大的，所以我们可以提前创建好一个空间来提前创建好线程，我们直接给这些创建好的线程分配任务即可。但是为什么直接取线程就一定比创建线程来的快呢？
手动创建线程池代码实例(简易demo)
qq_25995119的博客
03-16 1148
1.JDK 自带工具类创建的线程池的四种方式 newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。 newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺
Java 线程池详解及创建简单实例
08-31
Java线程池是一种高效管理并发任务的机制，它通过复用已存在的线程来减少线程创建和销毁的开销，从而提高系统的整体性能。...同时，阅读源代码也是提升技能的有效途径，可以让我们更深入地了解Java并发库的实现细节。
C++实现线程池详解（基于boost源码以及封装等线程池）
10-15
一、要实现高效的线程池，可以考虑以下几点 二、实现线程池可以按照以下步骤进行 三、简单的C++线程池代码示例 四、 基于boost编写的源码库 - 线程池 4.1 基于boost编写的源码库地址 4.2 boost线程池的先进先出、...
python多进程使用及线程池的使用方法代码详解
09-20
Python的`concurrent.futures`模块提供了线程池的实现。 ```python from concurrent.futures import ThreadPoolExecutor import time def sayhello(a): print(f"hello: {a}") time.sleep(2) def main(): seed ...
线程池使用示例（含源代码）
09-10
简单演示了如何使用线程池，可以再源代码的基础上进行修改进行更高级的操作，适合用于学习
线程池代码
06-10
比较简单的实现了一个线程池，，欢迎下载，，，，，，，
线程池的源代码，很简单的
06-26
线程池的源代码，很简单的，只是一些简单的例子
线程池的实现（JAVA）
01-04
很多人仅仅了解过线程池的强大，确没有亲自动手去实现。在这里提供一份用JAVA写的实例代码，供大家参考。
Java 线程池 – ThreadPoolExecutor 示例
qq2981118661的博客
06-14 1296
为什么需要Java 中的线程池？答案通常是当您在 Java 中开发一个简单的并发应用程序时，您会创建一些`Runnable`对象，然后创建相应的`Thread`对象来执行它们。在 Java 中创建线程是一项昂贵的操作。而且如果你每次都开始创建新的线程实例来执行任务，应用程序的性能肯定会下降。...
Java线程池完全解析及使用(附代码)
Ives_WangShen的博客
10-09 458
线程池知识及应用总结
线程池的简单实例
qq_51931826的博客
05-10 721
线程池的简单实例
java线程池超详细解析
weixin_43860634的博客
10-11 252
java线程池超详细解析
Java阻塞队列与线程池详解：ArrayBlockingQueue、LinkedBlockingQueue与SynchronousQueue
常见的线程池实现如Executor框架中的ThreadPoolExecutor。 3. **File类**: File类是Java中用于处理文件和目录的基本类，提供了文件和目录的路径操作、读写操作等方法。对于多线程环境，了解如何正确处理文件I/O，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值