Linux高性能服务器编程:进程池和线程池原理及应用(有图有代码有真相!!!)

Ubuntu 18.04下Apache Event MPM与PHP-FPM高性能配置指南 Apache MPM(多路处理模块)是决定Web服务器并发能力的核心机制,而PHP-FPM作为独立的PHP进程管理器,解决了传统mod_php的内存冗余与单点故障问题。二者协同构建了现代PHP应用的稳定运行时架构:Event模式通过事件驱动和异步I/O大幅提升连接复用效率,PHP-FPM则实现进程隔离、动态扩缩与资源精细化管控。该组合在中高并发场景(如Laravel/Symfony站点、多租户PHP服务)中显著降低内存占用、提升响应速度并增强容错性。本文聚焦Ubuntu 18.04这一关键LTS版本,详解其 阅读详情

一、问题引入

在前面编写多进程、多线程服务器时通过动态创建子进程和子线程来实现并发服务器,这样做有以下缺点:

1)动态创建进程、线程将会比较耗费时间,将导致较慢的客户响应。

2)动态创建的子进程只为一个客户服务,将会产生大量的细微进程或线程,进程或线程之间的切换将耗费CPU大量的时间。

3)动态创建的子进程是当前进程的完整映像,当前进程必须谨慎管理其分配的文件描述符和堆内存等系统资源,否则子进程可能复制这些资源,使系统可用资源急剧下降,

进而影响服务器性能。

要解决这些问题就要引入进程池、线程池。

二、进程池、线程池

1、池的概念

由于服务器的硬件资源“充裕”,那么提高服务器性能的一个很直接的方法就是以空间换时间,即“浪费”服务器的硬件资源,以换取其运行效率。

这就是池的概念。池是一组资源的集合,这组资源在服务器启动之初就完全被创建并初始化,这称为静态资源分配。当服务器进入正是运行阶段

,即开始处理客户请求的时候,如果它需要相关的资源,就可以直接从池中获取,无需动态分配。很显然,直接从池中取得所需资源比动态分配资

源的速度要快得多,因为分配系统资源的系统调用都是很耗时的。当服务器处理完一个客户连接后,可以把相关的资源放回池中,无需执行系统调

用来释放资源。从最终效果来看,池相当于服务器管理系统资源的应用设施,它避免了服务器对内核的频繁访问。

池可以分为多种,常见的有内存池、进程池、线程池和连接池。


2、 进程池、线程池

进程池和线程池相似,所以这里我们以进程池为例进行介绍。如没有特殊声明,下面对进程池的讨论完全是用于线程池。进程池是由服务器预先

创建的一组子进程,这些子进程的数目在3~10个之间(当然这只是典型情况)。线程池中的线程数量应该和CPU数量差不多。进程池中的所有子进程都运行着

相同的代码,并具有相同的属性,比如优先级、PGID等。当有新的任务来到时,主进程将通过某种方式选择进程池中的某一个子进程来为之服务。

相比于动态创建子进程,选择一个已经存在的子进程的代价显得小得多。至于主进程选择哪个子进程来为新任务服务,则有两种方法:

1)主进程使用某种算法来主动选择子进程。最简单、最常用的算法是随机算法和Round Robin(轮流算法),但更优秀、更智能的算法使得任务在各个工作进程中均匀的分配

,从而减轻服务器的整体压力

2)主进程和所有子进程通过一个共享的工作队列来同步,子进程都睡眠在该工作队列上。当有新的任务到来时,主进程将任务添加到工作队列中。这将唤醒正在等待任       务的子进程,不过只有一个子进程将获得新任务的“接管权”,它可以从工作队列中取出任务并执行之,而其他子进程将继续睡眠在工作队列上。


当选择好子进程后,主进程还需要使用某种通知机制来告诉目标子进程有新任务需要处理,并传递必要的数据。最简单的方式是,在父进程和子进程之间预先建立好一

条管道,然后通过管道来实现所有的进程间通信。在父线程和子线程之间传递数据就要简单得多,因为我们可以把这些数据定义为全局,那么它们本身就是被所有线程共享的。

三、进程池、线程池的部分应用


1、应用进程池处理多客户

在使用进程池处理多客户任务时,首先要考虑的一个问题是:监听 socket 和连接 socket 是否都由进程统一管理这两种 socket 。这可以一下介绍的并发模式解决。服务器主要有两种并发编程模式:半同步 / 半异步模式和领导者 / 追随者模式。

其次,在设计进程池时还需要考虑:一个客户连接上的所有任务是否始终由一个子进程来处理。如果说客户任务是无状态的,那么我们可以考虑使用不同的子进程来为该客户的不同请求服务。但如果客户是存在上下文关系的,则最好一直用同一个子进程来为之服务,否则实现起来比较麻烦,因为我们不得不在各子进程之间传递上下文数据。 epoll 的 EPOLLONESHOT 事件能够确保一个客户连接在整个生命周期中仅被一个线程处理。




2、线程池主要用于:

1)、需要大量的线程来完成任务,且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务,使用线程池技术是非常合适的。因为单个任务小,而任务数量巨大,你可以想象一个热门网站的点击次数。但对于长时间的任务,比如一个Telnet连接请求,线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。

2)、对性能要求苛刻的应用,比如要求服务器迅速响应客户请求。

3)、接受突发性的大量请求,但不至于使服务器因此产生大量线程的应用。突发性大量客户请求,在没有线程池情况下,将产生大量线程,虽然理论上大部分操作系统线程数目最大值不是问题,短时间内产生大量线程可能使内存到达极限,并出现"OutOfMemory"的错误。

3、c模拟实现线程池

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

  
/* 要执行的任务链表 */
typedef struct tpool_work {
     void*               (*routine)(void*);       /* 任务函数 */
     void                *arg;                    /* 传入任务函数的参数 */
     struct tpool_work   *next;                    
 }tpool_work_t;
  
 typedef struct tpool {
     int             shutdown;                    /* 线程池是否销毁 */
     int             max_thr_num;                /* 最大线程数 */
     pthread_t       *thr_id;                    /* 线程ID数组 */
     tpool_work_t    *queue_head;                /* 线程链表 */
     pthread_mutex_t queue_lock;                    
     pthread_cond_t  queue_ready;    
 }tpool_t;
  
//创建线程池
int tpool_create(int max_thr_num);
//销毁线程池 

void tpool_destroy();
  
int tpool_add_work(void*(*routine)(void*), void *arg);
   
 static tpool_t *tpool = NULL;
  
 /* 工作者线程函数, 从任务链表中取出任务并执行 */
static void* thread_routine(void *arg)
{
       tpool_work_t *work;
       
       while(1) {
           // 如果线程池没有被销毁且没有任务执行,会处于阻塞状态,
            //pthread_cond_wait是一个原子操作,等待前会解锁,唤醒后会加锁 
           pthread_mutex_lock(&tpool->queue_lock);
           while(!tpool->queue_head && !tpool->shutdown) {
	       printf ("thread %lu is waiting\n", pthread_self ());
               pthread_cond_wait(&tpool->queue_ready, &tpool->queue_lock);
           }
	   //线程池要销毁了
           if (tpool->shutdown) {
               pthread_mutex_unlock(&tpool->queue_lock);
	       printf ("thread %lu will exit\n", pthread_self ());
               pthread_exit(NULL);
           }
           work = tpool->queue_head;
           tpool->queue_head = tpool->queue_head->next;
           pthread_mutex_unlock(&tpool->queue_lock);
    
           work->routine(work->arg);
           free(work);
       }
       
       return NULL;   
   }
    
//  * @brief     创建线程池 
//  * @param     max_thr_num 最大线程数
//  * @return     0: 成功 其他: 失
   int tpool_create(int max_thr_num)
   {
       int i;
    
       tpool = calloc(1, sizeof(tpool_t));
       if (!tpool) {
           printf("%s: calloc failed\n", __FUNCTION__);
           exit(1);
       }
       
       /* 初始化 */
       tpool->max_thr_num = max_thr_num;
       tpool->shutdown = 0;
       tpool->queue_head = NULL;
       if (pthread_mutex_init(&tpool->queue_lock, NULL) !=0) {
           printf("%s: pthread_mutex_init failed, errno:%d, error:%s\n",
               __FUNCTION__, errno, strerror(errno));
           exit(1);
       }
       if (pthread_cond_init(&tpool->queue_ready, NULL) !=0 ) {
           printf("%s: pthread_cond_init failed, errno:%d, error:%s\n", 
               __FUNCTION__, errno, strerror(errno));
           exit(1);
       }
       
       /* 创建工作者线程 */
       tpool->thr_id = calloc(max_thr_num, sizeof(pthread_t));
       if (!tpool->thr_id) {
           printf("%s: calloc failed\n", __FUNCTION__);
           exit(1);
       }
       for (i = 0; i < max_thr_num; ++i) {
           if (pthread_create(&tpool->thr_id[i], NULL, thread_routine, NULL) != 0){
               printf("%s:pthread_create failed, errno:%d, error:%s\n", __FUNCTION__, 
                   errno, strerror(errno));
               exit(1);
           }
           
       }    
    
       return 0;
   }
    
   /* 销毁线程池 */
   void tpool_destroy()
   {
       int i;
       tpool_work_t *member;
    
       if (tpool->shutdown) {
           return;
       }
       tpool->shutdown = 1;
    
       /* 通知所有正在等待的线程 */
       pthread_mutex_lock(&tpool->queue_lock);
       pthread_cond_broadcast(&tpool->queue_ready);
      pthread_mutex_unlock(&tpool->queue_lock);
      for (i = 0; i < tpool->max_thr_num; ++i) {
          pthread_join(tpool->thr_id[i], NULL);
      }
      free(tpool->thr_id);
   
      while(tpool->queue_head) {
          member = tpool->queue_head;
          tpool->queue_head = tpool->queue_head->next;
          free(member);
      }
   
      pthread_mutex_destroy(&tpool->queue_lock);    
      pthread_cond_destroy(&tpool->queue_ready);
   
      free(tpool);    
  }
   
   //* @brief     向线程池中添加任务
  //* @param    routine 任务函数指针
  //* @param     arg 任务函数参数
  //* @return     0: 成功 其他:失败 
  int tpool_add_work(void*(*routine)(void*), void *arg)
  {
      tpool_work_t *work, *member;
      
      if (!routine){
          printf("%s:Invalid argument\n", __FUNCTION__);
          return -1;
      }
      
      work = malloc(sizeof(tpool_work_t));
      if (!work) {
          printf("%s:malloc failed\n", __FUNCTION__);
          return -1;
      }
      work->routine = routine;
      work->arg = arg;
      work->next = NULL;
   
      pthread_mutex_lock(&tpool->queue_lock);    
      member = tpool->queue_head;
      if (!member) {
          tpool->queue_head = work;
      } else {
          while(member->next) {
              member = member->next;
          }
          member->next = work;
      }
      /* 通知工作者线程,有新任务添加 */
     pthread_cond_signal(&tpool->queue_ready);
     pthread_mutex_unlock(&tpool->queue_lock);
  
     return 0;    
 }
 //测试 
 void *func(void *arg)
 {
     printf("thread %d\n", (int)arg);
     return NULL;
 }
  
 int main(int arg, char **argv)
 {
     if (tpool_create(5) != 0) {
         printf("tpool_create failed\n");
         exit(1);
     }
     
     int i;
     for (i = 0; i < 12; ++i) {//给线程池分配任务
         tpool_add_work(func, (void*)i);
     }
     sleep(2);
	tpool_destroy();//销毁线程池
     return 0;
 }

结果:





多核CPU性能释放指南:从原理到Python/Node.js实战 多核CPU是现代计算的基础设施,但其并行能力能否发挥,取决于软件是否突破GIL、内存一致性、I/O阻塞等底层限制。理解物理核心与逻辑线程的本质差异,掌握阿姆达尔定律对加速比的约束,是高效利用硬件的前提。技术价值在于将CPU利用率从单核瓶颈提升至接近100%的多核协同,显著缩短计算密集型任务耗时。典型应用场景包括Python批量数据处理、Node.js高并发服务、科学计算与实时音视频处理。本文聚焦开发者视角,结合进程级并行、共享内存、CPU亲和性等关键技术,提供可落地的多核激活方案。 阅读详情

相关推荐

虚拟机vCPU超配诊断与优化:从原理到实践的完整指南

在虚拟化环境中,CPU调度是保障性能的核心机制。其基本原理是通过虚拟化层调度器,将多个虚拟CPU(vCPU)的时间片在物理CPU(pCPU)核心上进行分时复用。当vCPU数量配置不合理,尤其是单台虚拟机的vCPU数超过物理机逻辑处理器总数时,会引发严重的调度器过载。这会导致上下文切换开销激增、就绪队列拥堵以及CPU高速缓存频繁失效,进而造成虚拟机性能抖动、响应迟缓,甚至影响整个宿主机稳定性。理解CPU就绪时间等关键监控指标,对于诊断此类资源争用问题至关重要。本文聚焦于虚拟机vCPU超量配置这一常见运维陷阱,

weixin_34221775的博客 312

c语言进程池原理及实现

进程池与线程池出发点一样,都是考虑多核情况下任务的并行处理; 从多进程和多线程编程的区别上看,多线程有许多的同步、互斥的方法,较擅长于异步协作;而多进程同步、互斥的方法相对比较麻烦,则更多地考虑上下文独立执行; 从Nginx使用线程池/进程池处理大并发的思路去分析,其实就是多客户端大量连接的场景;主进程监听是否有新客户端tcp连接,然后分发给工作进程去响应http请求,在这种场景下每个连接都是一个独立的上下文逻辑,每个工作进程的内容都是对等地处理http请求,这种情况就非常适合进程池的方式; 把上述的.

jenie的专栏 1898

浅析Python自带的线程池和进程池

线程池和进程池是Python中实现并发编程的重要工具,它们可以有效地管理和调度多线程或多进程执行任务,提高程序的性能和响应能力。在选择使用线程池还是进程池时,需要根据具体的应用场景和需求来决定。对于I/O密集型任务,线程池是一个不错的选择;而对于CPU密集型任务,尤其是需要利用多核资源的情况,进程池更为合适。同时,我们也需要注意线程池和进程池在使用中可能遇到的问题,如线程间的竞态条件、进程间的通信开销等,并采取相应的措施来解决这些问题。

这家伙很懒,什么都没有留下 1763

进程池是干什么的?底层原理是什么?

程序在启动时会创建一定数量的进程,并将它们保存在池中。当有任务到来时,程序会从池中选择一个空闲的进程,并将任务参数传递给该进程。进程池是一种常见的多进程编程技术,它可以在程序启动时预先创建一定数量的进程,并将这些进程保存在池中以备后续使用。当有任务需要处理时,程序会从进程池中取出一个空闲的进程来处理任务,任务处理完毕后,该进程会被放回进程池中,等待下一个任务的到来。进程池技术可以显著提高程序的性能和并发处理能力,因为它避免了频繁地启动和关闭进程的开销,而是预先创建了一定数量的进程,并且这些进程可以被复用。

长风破浪会有时的博客 559

Select、Poll与Epoll 的比较

1 Select、Poll与Epoll简介 Select select本质上是通过设置或者检查存放fd标志位的数据结构来进行下一步处理。 如果有事件发生,select会将临时结果写到用户空间并返回;当轮询一遍后没有任何事件发生时,如果指定了超时时间,则select会睡眠到超时,睡眠结束后再进行一次轮询,并将临时结果写到用户空间,然后返回。 sel

h a 6 6 6 c k 为 你解决复杂难题! 857

STK中的传感器与通信组件:雷达、发射机、接收机与天线的协同建模

本文深入解析了STK软件中传感器、雷达、发射机、接收机与天线的协同建模方法。通过构建一个完整的卫星对地数传系统实例,阐述了各组件如何分工协作,实现从几何指向到射频链路的高保真仿真,为复杂航天通信与探测系统的设计与分析提供了高效、灵活的解决方案。

weixin_29271263的博客 274

深入了解linux系统—— 进程池

进程池技术是一种通过预先创建并复用进程资源来提升系统性能和资源利用率的优化方法。本文介绍了进程池的实现原理,包括通过匿名管道进行父子进程通信,让父进程管理子进程执行任务。具体实现上,首先设计channel类描述单个进程管道,channel_manage类组织管理管道,channel_pool类描述整个进程池。初始化时创建多个子进程,子进程持续等待父进程通过管道发送任务指令,父进程则记录各子进程信息。子进程通过读取管道中的整数指令来执行对应任务。这种设计避免了频繁创建销毁进程的开销,实现了进程资源的复用。

LH__1314的博客 1434

华为开发岗暑期实习笔试(2025年4月16日)

第一题怀疑测试样例不完整,贪心法不应该能够解决该题。第二题使用0-1BFS解决单源最短路径的问题,往往搭配双端队列实现。第三题是运用动态规划解决最大不重叠子区间个数的问题,难点在于满足3重判断规则,所需数据结构及相关操作较多。

csy031117的博客 3664

进程池详解

提前建立一堆进程,而不是从头开始建立进程例如,我们执行命令的时候,命令本身也是进程,所以需要bash创建进程要从头开始创建进程PCB、分配空间等成本很高如果每一次都要从头开始建立,很浪费时间成本所以,为了提高效率,提前建立多个子进程等待在父进程和子进程之间,建立单向管道通信当父进程有任务需要子进程执行时,直接把任务写入管道中对应管道的子进程读取数据,开始执行分配的任务如果父进程没有分配任务,子进程就处于等待阻塞的状态当父进程分配任务时,叫做唤醒子进程。

qq_51216031的博客 1568

[RK3588-Android12] 深入解析USB Type-C PD充电功能的DTS配置与内核驱动修改

本文深入探讨了在RK3588 Android12平台上禁用USB Type-C PD充电功能的实现方法。通过分析设备树(DTS)配置与内核驱动(TCPM框架)的联动修改,详细解读了如何通过添加`pd-disable`属性及修改`tcpm.c`驱动代码,使Type-C端口绕过PD协议协商,仅工作在传统电源模式,以满足工控等特定场景对供电稳定性和成本控制的需求。

9o8p7i6u5y的博客 995

SerDes硬件设计原理介绍

接收端:外部差分串行数据------线性均衡器----(CDR从数据中恢复出采样时钟)-----解串器(串行信号转并行信号)-------8B/10B的解码器或解扰器-----FIFO-----FPGA接受差分并行数据。发送端: FPGA发送差分并行数据----FIFO------8B/10B编码器或者扰码器-----串行器(并行信号转串行信号)-----均衡器(滤波)--------TX串行信号差分外发。串行器:8bit的并行数据----2bit的并行数据----1bits的串行数据。

weixin_42304393的博客 1111

进程(六):进程池(Pool)

目录 进程池 multiprocess.Pool模块 概念介绍 参数介绍 主要方法 其他方法(了解) 代码实例 回调函数 进程池 为什么要有进程池?进程池的概念。 在程序实际处理问题过程中,忙时会有成千上万的任务需要被执行,闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候,我们就需要去创建成千上万个进程么?首先,创建进程需要消耗时间,销毁进程也需要消耗时间。第二即便...

。 9827

SAP 运费处理方式

从直接的处理方式上看,情况1/2/3可以将运费记账到物料成本中,但情况4/5/6是直接记账到成本对象中,具体是要体现在损益表中,还是要结转到物料成本中,可依据业务要求进行好处理。如果体现在损益表中,不需要多过多额外的操作,如果要体现在物料成本中心,则需要再进行一系列的处理,最终将金额结转到物料成本中。因为在创建采购订单时不知道具体运费,可以不维护运费,只需要维护材料价格。:创建采购订单时,运费是由供应商承担,很多时候是包含在材料报价中,这种情况不需要专门针对运费进行处理,材料价格中已包含运费。

weixin_44506537的博客 3375

Linux高性能服务器编程——进程池和线程池

进程池和线程池 池的概念 由于服务器的硬件资源“充裕”,那么提高服务器性能的一个很直接的方法就是以空间换时间,即“浪费”服务器的硬件资源,以换取其运行效率。这就是池的概念。池是一组资源的集合,这组资源在服务器启动之初就完全被创建并初始化,这称为静态资源分配。当服务器进入正是运行阶段,即开始处理客户请求的时候,如果它需要相关的资源,就可以直接从池中获取,无需动态分配。很显然,直接

walkerkalr的专栏 8613

【重启后nvidia-smi 命令出现错误】

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver. Make sure that the latest NVIDIA driver is installed and running.

qq_44769377的博客 5217

深入剖析 Wenet 下 AISHELL-1 的 run.sh 脚本:从数据准备到模型训练

run.sh脚本用于处理 AISHELL-1 数据集的整个训练和测试流程。我们将逐步分析脚本中的每个部分,包括环境变量、参数设置、各个阶段的执行等。stage: 设置脚本的起始阶段(如数据准备)。stop_stage: 设置脚本的结束阶段。通过对 Wenet 下 AISHELL-1 的run.sh脚本的详细剖析,我们希望你能更好地理解每个步骤的功能及其背后的原理。此脚本不仅为模型训练提供了便利,也为用户自定义和扩展训练流程提供了基础。希望本教程能帮助你顺利完成语音识别项目!

帅小柏的博客 1635

15.Linux 高性能服务器编程 --- 进程池和线程池

1.动态创建进程和线程缺点: 1.动态创建进程(或线程)比较耗费时间 2.动态创建的子进程(或子线程)通常只用来为一个客户服务,这将导致系统上产生大量的细微进程(或线程)。 进程(或线程)间的切换将消耗大量CPU时间。 3.动态创建的子进程是当前进程的完整映像。当前进程必须谨慎的管理其分配的文件描述符和堆内存等系统资源。 否则子进程可能复制这些资源,从而使系统的可用资源急剧下降,进而影...

enlyhua的专栏 885

引入高分辨率特征层保持的YOLOv10小目标增强:从思路到完整实现

大概两个月前,我在做一个无人机航拍图像检测的项目,目标是识别图片里的小型车辆和行人。用的数据集是VisDrone,相信做小目标检测的朋友对这个数据集都不陌生。一开始我直接跑了官方YOLOv10的代码,结果在tiny vehicle这一类上mAP50只有可怜的0.312。那些小目标基本就是几个像素点,YOLOv10在三次下采样之后,这些小目标的特征几乎就消失不见了。 后来我折腾了大概三周,尝试了各种方法:改anchor、调loss权重、做数据增强、甚至考虑过换检测头。最后发现最有效的还是引入一个高分辨率特征

YOLO 51

java多线程总结五:线程池的原理及实现

1、线程池简介:     多线程技术主要解决处理器单元内多个线程执行的问题,它可以显著减少处理器单元的闲置时间,增加处理器单元的吞吐能力。         假设一个服务器完成一项任务所需时间为:T1 创建线程时间,T2 在线程中执行任务的时间,T3 销毁线程时间。     如果:T1 + T3 远大于 T2,则可以采用线程池,以提高服务器性能。                 一个线程

stefshawn的专栏 3183

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

进程池和线程池

1) 动态创建子进程(子线程)来实现并发服务器有如下缺点: 动态创建进程(线程)是比较耗时的,这将导致较慢的客户响应; 动态创建子进程(线程)通常是为一个客户服务的(除非我们做特殊的处理),这将导致系统上产生大量的细微进程(线程),进程(线程)间的切换将消耗大量的CPU时间; 动态创建的子进程是当前进程的完整映像,当前进程必须谨慎的管理其分配的文件描述符和堆内存等系统资源,否则子进程可能复制这些资源

喜欢恋着风 294

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Java 并发编程深入学习——线程池及其实现原理

Java线程池介绍   线程池,从字面含义来看,是指管理一组同构工作线程的资源池。线程池是与工作队列(work Queue)密切相关的,其中工作队列中保存了所有等待执行的任务。工作者线程(Work Thread)的任务很简单:从工作队列中获取一个任务,执行任务,然后返回线程池并等待下一个任务。 使用线程池的优势   在线程池中执行任务比为每个任务分配一个线程优势更多。通过重用现有的线程而不是

BridgeGeorge 2516

进程池详解(linux)

进程池 进程池是我们创建一组进程,进程数目可以自己的规定,目的是为了让我们可以并发的去处理任务,此文处理的是网络请求的进程池。 采用的是半同步/半反应堆模式的进程池。 主进程epoll监听listenfd,如有客户连接根据特定算法将客户连接套接字利用管道发送给进程池中的某个进程,让其进行监听。该算法主要是为了平衡进程池中每个进程epoll监听的套接字数量。防止某个进程监听过多性能降低。 然后每个进...

weixin_42250655的博客 1203

线程池原理(讲的非常棒)

Java并发编程:线程池的使用   在前面的文章中,我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题:   如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。   那么有没有一种办法使得线程可以复用,就是执行完一个任务,并不被销毁,而是可以继续执行其他的任

gol_phing的博客 3万+

进程池

进程池 为什么要有进程池 开启过多的进程并不能提高你的效率,反而会降低你的效率,因为如果有500个任务,同时开启500个进程,这500个进程除了不能一起执行之外(cpu没有那么多核),操作系统还要占空间,并且操作系统还有调度这500个进程,让他们平均在4个或8个cpu上执行。 程序分为两种类型: 计算型: 适合开启多进程,但是不适合开启很多多进程。 充分占用cpu。适合使用多进程,因为多进程能充分...

python编程 7322

C语言实现简单线程池

有时我们会需要大量线程来处理一些相互独立的任务,为了避免频繁的申请释放线程所带来的开销,我们可以使用线程池。下面是一个C语言实现的简单的线程池。 头文件: 1: #ifndef THREAD_POOL_H__ 2: #define THREAD_POOL_H__ 3: 4: #include <pthread.h> ...

weixin_30780221的博客 507

Linux网络编程【四】:进程池、线程池原理及简单线程池源码分析

进程池和线程池概述 进程池和线程池相似,所以这里我们以进程池为例进行介绍。如没有特殊声明,下面对进程池的讨论完全是用于线程池。 进程池是由服务器预先创建的一组子进程,这些子进程的数目在 3~10 个之间(当然这只是典型情况)。线程池中的线程数量应该和 CPU 数量差不多。 进程池中的所有子进程都运行着相同的代码,并具有相同的属性,比如优先级、 PGID 等。 当有新的任务来临时,主进程将通过某种方式选择进程池中的某一个子进程来为之服务。相比于动态创建子进程,选择一个已经存在的子进程的代价显得小得多。至于主

Begin 1130
上一篇: 网络:TCP通讯之 time_wait 状态
下一篇: Linux:多进程、多线程服务器的实现解析(有图有代码有真相!!!)
Sharp_UP
博客等级 码龄10年 86粉丝 78原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值