背景

原文連結： http://blog.csdn.net/ordeder/article/details/21721141

1.程序A在n埠上監聽，即呼叫listen(listenfd,backlog);

2.之後A呼叫fork產生子程序B，此時B拷貝了A的listenfd，該描述符使用的是相同的“檔案表項”（具體參考 http://blog.csdn.net/ordeder/article/details/21716639）

3.那麼A程序和B程序將共享一個socket，具體圖解如下：

驚群現象        

        在該模型下（多個子程序同時共享監聽套接字）即可實現伺服器併發處理客戶端的連線。這裡要注意的是，計算機三次握手建立連線是不需要服務程序引數的，而服務程序僅僅要做的事呼叫accept將已建立的連線構建對應的連線套接字connfd（可參考 http://blog.csdn.net/ordeder/article/details/21551567）。多個服務程序同時阻塞在accept等待監聽套接字已建立連線的資訊，那麼當核心在該監聽套接字上建立一個連線，那麼將同時喚起這些處於accept阻塞的服務程序，從而導致“驚群現象”的產生，喚起多餘的程序間影響伺服器的效能（僅有一個服務程序accept成功，其他程序被喚起後沒搶到“連線”而再次進入休眠）。

例項分析

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>       /* basic system data types */
#include<sys/socket.h>      /* basic socket definitions */
#include<netinet/in.h>      /* sockaddr_in{} and other Internet defns */
#include<arpa/inet.h>       /* inet(3) functions */
#include<sys/epoll.h>           /* epoll function */
#include<fcntl.h>
#include<stdlib.h>
#include<errno.h>
#include<stdio.h>
#include<string.h>
#include<sys/select.h>

#define WORKERSIZE 3

void waitall()
{
        pid_t cpid;
        while(1)
        {
           cpid = wait(NULL);
           if(cpid==-1){
	       perror("end of wait");
               break;
           }
           printf("worker pid#%d exit...\n",cpid);
        }
}

void worker_hander(int listenfd)
{
        fd_set rset;
        int cnt = 100,connfd,rc;
        struct timeval tv;
        tv.tv_sec = 0;
        tv.tv_usec=0;

        printf("worker pid#%d is waiting for connection...\n",getpid());

        while(1)
        {
                FD_ZERO(&rset);
                FD_SET(listenfd,&rset);

                //rc = select(listenfd+1,&rset,NULL,NULL,&tv);//設定為非阻塞狀態
		rc = select(listenfd+1,&rset,NULL,NULL,NULL);//設定為阻塞

                if(rc == -1) perror("select");
 		else if(rc>0 && FD_ISSET(listenfd,&rset))
                {
			//sleep(1);//第四種，讓三個程序都有足夠的時間資源喚起（防止可能出現某個程序已近開始進行accept結束了，另一個程序還未被喚起(排程的問題)）
                        printf("worker pid#%d 's listenfd is readable\n",getpid(),rc);
                        connfd = accept(listenfd,NULL,0);
                        if(connfd == -1)
                        {
                                perror("accept error");
                                continue;
                        }
                        printf("worker pid#%d create a new connection...\n",getpid());
                        sleep(1);
                        close(connfd);
                }
        }
}

int main(int argc,char*argv[])
{
        int listenfd,connfd;
        struct sockaddr_in cliaddr,servaddr;
        int queuelen=5,i,flag;
        pid_t cpid[WORKERSIZE];

        listenfd = socket(AF_INET,SOCK_STREAM,0);

	//此處設定listenfd的為阻塞
        /*flag = fcntl(listenfd,F_GETFL,0);
        fcntl(listenfd,F_SETFL,flag|O_NONBLOCK);*/

        bzero(&servaddr,sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        inet_pton(AF_INET,"172.20.52.140",&servaddr.sin_addr);
        //servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        servaddr.sin_port = htons(2989);

        bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));

        listen(listenfd,queuelen);

        for(i=0;i<WORKERSIZE;i++)
        {
                cpid[i]=fork();
                if(cpid[i] == -1){
                        perror("fork error");
                        waitall();
                        exit(0);
                }
                if(cpid[i]==0){
                        worker_hander(listenfd);
                        exit(0);
                }
        }
        waitall();
	return 0;
}
 

不同設定的結果輸出：

一個客戶端發起連結，而服務端有三個服務程序在監聽同一埠，從而核心會喚起所有處於監聽該埠的服務程序，從而導致驚群現象的發生。服務端設定不通的阻塞情況，可得如下不同的結果：

一個客戶端發起連結，而服務端有三個服務程序在監聽同一埠。服務端設定不通的阻塞情況，可得如下不同的結果。
1.select設定為阻塞，listenfd設定為阻塞或非阻塞，結果如下：
worker pid#25583 is waiting for connection...
worker pid#25584 is waiting for connection...
worker pid#25585 is waiting for connection...
worker pid#25585 's listenfd is readable
worker pid#25585 create a new connection...
分析：三個服務程序被喚起，25585第一個排程所以執行accept，所以此時連線被取走，其他兩個程序之後開始被排程，而此時連線數目為0，又進入隨眠...

2.select設定為非阻塞，listenfd設定為阻塞，結果如下：
worker pid#25743 is waiting for connection...
worker pid#25744 is waiting for connection...
worker pid#25745 is waiting for connection...
worker pid#25745 's listenfd is readable
worker pid#25744 's listenfd is readable
worker pid#25743 's listenfd is readable
worker pid#25745 create a new connection...
分析：三個服務程序都select都成功返回可讀的套接字，從而各個程序都喚起處於阻塞的accept，但是隻有一個程序建立連結，其餘兩個程序沒有獲取到連結而又進入睡眠...

3.select設定為非阻塞，listenfd設定為為非阻塞，結果如下：
worker pid#25240 is waiting for connection...
worker pid#25241 is waiting for connection...
worker pid#25242 is waiting for connection...
worker pid#25242 's listenfd is readable
worker pid#25240 's listenfd is readable
worker pid#25241 's listenfd is readable
worker pid#25242 create a new connection...
accept error: Resource temporarily unavailable
accept error: Resource temporarily unavailable
分析：三個服務程序都進入accept，但是隻有一個程序獲取到連結，其他兩個程序沒有獲取到連結而出錯

4.在select設定為阻塞，select和accept之間新增sleep(1)，accept的套接字為非阻塞，結果如下：
worker pid#30689 is waiting for connection...
worker pid#30690 is waiting for connection...
worker pid#30691 is waiting for connection...
worker pid#30691 's listenfd is readable
worker pid#30691 create a new connection...
worker pid#30690 's listenfd is readable
worker pid#30689 's listenfd is readable
accept error: Resource temporarily unavailable
accept error: Resource temporarily unavailable
分析：三個程序被喚起後，由於有sleep(1)，三個程序都被排程了，所以select都能查詢到連線，故而從select返回，但是在accept處，只有一個程序得到了連線