nginx 子进程调度

来源：互联网发布：会计毕业论文知乎编辑：程序博客网时间：2024/06/02 04:24

在linux 下,nginx默认是采用多进程模型的，其中一个是父进程，其他都是子进程，父进程主要做一些全局初始化、调度等工作，而真正的处理时在子进程中完成的，那么当一个请求过来的时候，到底有那个进程去服务呢？

我看了代码，还是没有找到答案，后来在网上发现了这篇文章<<Nginx0.7.61代码分析(二)--worker子进程之间的负载均衡>>，终于揭开了我心中的疑问。系统根据没有进程已有的链接数来进程调度的。

这里对相关的问题进行总结:

一子进程可以继承父进程的socket的，所以如果在父进程中启动了监听的socket后，在子进程中直接进行accept, 这个就是nginx使用的方法。

二 nginx其实不是很好的调度算法，它只是对于负担比较重的进程，不给他们分配任务，所以在任务不是很多的时候，这个算法并不是很好。

下面自己写了一个简单的程序，父进程启动监听进程，子进程进程accept，利用共享内存，实现进程之间的通信，使他们轮流执行任务。

[cpp] view plaincopy
#include <sys/socket.h>  
#include <sys/epoll.h>  
#include <netinet/in.h>  
#include <arpa/inet.h>  
#include <fcntl.h>  
#include <unistd.h>  
#include <stdio.h>  
#include <pthread.h>  
#include <errno.h>  
#include <unistd.h>  
#include <sys/ipc.h>  
#include <sys/shm.h>  
#include <errno.h>  
  
#define KEY 1234   
#define SIZE 1024   
  
#define PORT 9999   
#define MAXFDS 5000  
#define EVENTSIZE 100  
  
void process();   
  
int fd, cfd,opt=1;  
int shmid;  
char *shmaddr;  
struct shmid_ds buf;  
int num = 0 ;   
  
int main(int argc, char *argv[])  
{  
    shmid = shmget(KEY,SIZE,IPC_CREAT|0600); /* 建立共享内存 */  
    if(shmid == -1){  
        printf("create share memory failed/n");   
    }  
    shmaddr = (char *)shmat(shmid,NULL,0);  
    if(shmaddr == (void *)-1){  
        printf("connect to the share memory failed: %s",strerror(errno));  
        return 0;  
    }  
    strcpy(shmaddr,"1/n");  
      
    struct sockaddr_in sin, cin;  
    socklen_t sin_len = sizeof(struct sockaddr_in);  
  
    if ((fd = socket(AF_INET, SOCK_STREAM, 0)) <= 0)  
    {  
        fprintf(stderr, "socket failed/n");  
        return -1;  
    }  
  
    memset(&sin, 0, sizeof(struct sockaddr_in));  
    sin.sin_family = AF_INET;  
    sin.sin_port = htons((short)(PORT));  
    sin.sin_addr.s_addr = INADDR_ANY;  
    if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)) != 0)  
    {  
         fprintf(stderr, "bind failed/n");  
         return -1;  
    }  
    if (listen(fd, 32) != 0)  
    {  
        fprintf(stderr, "listen failed/n");  
        return -1;  
    }  
    int i ;    
    for(i = 0; i < 2; i++)  
    {  
      int pid = fork();  
      if(pid == 0)  
      {  
          process();        
      }  
    }    
    while(1) ;   
     
    return 0;  
}  
  
void process()  
{  
    int pid = getpid();   
    struct sockaddr_in cin;  
    socklen_t sin_len = sizeof(struct sockaddr_in);  
    while(1)  
    {   
        shmaddr = (char *)shmat(shmid,NULL,0);  
        if(shmaddr == (void *)-1){  
        printf("connect the share memory failed: %s",strerror(errno));  
        return ;   
        }  
     
       if(shmaddr[0]=='0')  
           num = 0 ;   
       else num = 1;  
  
       if((pid-num)%2==0)   
       {  
            int fds = accept(fd,(struct sockaddr *)&cin, &sin_len);  
            if(fds>0)  
            {   
                 printf("my pid is %d/n",pid);        
                 fflush(stdout);    
                 if(num == 0)  
                     strcpy(shmaddr,"1/n");  
                 else    
                     strcpy(shmaddr,"0/n");  
            }  
       }  
       shmdt(shmaddr);  
    }  
}  

我们启动服务，在客户端输入

ab -n 1000 -c 100 http://ip:9999/

可以看到在服务器端，两个进程交替处理请求

my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707
my pid is 5708
my pid is 5707