Technorati 标签: ,
惊群也就是指多个进程阻塞在accept，当有连接完成，会唤醒所有进程。
经过测试，发现现在的内核已经修复了这个问题，当有多个进程阻塞在accept，只会唤醒一个进程。 下面这个是一篇论文，就是讲这个问题的。 http://www.usenix.org/event/usenix2000/freenix/full_papers/molloy/molloy.pdf 这里会先测试，然后分析内核代码。 下面是服务端的测试代码（很丑陋的代码，只是测试用):
#include#include #include #include #include #include #include #include #define SERV_PORT 9999int main(int argc,char **argv){ int listenfd,connfd; pid_t childpid,childpid2; socklen_t clilen; struct sockaddr_in cliaddr,servaddr; listenfd = socket(AF_INET,SOCK_STREAM,0); bzero(&servaddr,sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl (INADDR_ANY); servaddr.sin_port = htons (SERV_PORT); bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)); listen(listenfd,1000); clilen = sizeof(cliaddr); if( (childpid = fork()) == 0) { while(1) { connfd = accept(listenfd,(struct sockaddr *) &cliaddr,&clilen); printf("fork 1 is [%d],error is %m\n",connfd); } } if( (childpid2 = fork()) == 0) { while(1){ connfd = accept(listenfd,(struct sockaddr *) &cliaddr,&clilen); printf("fork 2 is [%d]，error is %m\n",connfd); } } sleep(100); return 1;}
可以看到我们fork两个进程同时阻塞在accept。当客户端connect完成之后，只有第一个子进程被唤醒。
不过这里要注意当用select这类监控listen的句柄的时候，有连接到来，这时所有的进程都会被唤醒的。这里的原因是因为对于select来说，数据不是互斥的，也就是说有可能就需要多个进程同时读取资源。而对于accept，只有可能是一个进程取得数据，因此这里如果用select监控listen的句柄然后阻塞的话，当有连接到来就会唤醒所有的进程，这里测试程序就不贴了。 ok，接下来我们来看源码中是如何做得。 首先我们知道当accept的时候，如果没有连接则会一直阻塞(没有设置非阻塞),而阻塞代码是在inet_csk_wait_for_connect中，这个代码我们前面已经分析过了，一次你我们来看代码片断：
/* * True wake-one mechanism for incoming connections: only * one process gets woken up, not the 'whole herd'. * Since we do not 'race & poll' for established sockets * anymore, the common case will execute the loop only once. * * Subtle issue: "add_wait_queue_exclusive()" will be added * after any current non-exclusive waiters, and we know that * it will always _stay_ after any new non-exclusive waiters * because all non-exclusive waiters are added at the * beginning of the wait-queue. As such, it's ok to "drop" * our exclusiveness temporarily when we get woken up without * having to remove and re-insert us on the wait queue. */ for (;;) { prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
这里注释非常详细，就是说它是exclusive的，然后我们来看prepare_to_wait_exclusive，它很简单就是将当前的进程加到socket的等待队列sk_sleep中：
voidprepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state){ unsigned long flags;///最关键的在这里我们看到设置等待队列的flag为EXCLUSIVE，设置这个就是表示一次只会有一个进程被唤醒，我们等会就会看到这个标记的作用。 wait->flags |= WQ_FLAG_EXCLUSIVE; spin_lock_irqsave(&q->lock, flags);//加入到等待队列。 if (list_empty(&wait->task_list)) __add_wait_queue_tail(q, wait); set_current_state(state); spin_unlock_irqrestore(&q->lock, flags);}
这边添加的分析完了，我们来看唤醒的实现。
下面分析的代码，我前面的blog基本已经分析完了，因此下面只是一些代码片断。 首先我们知道当有tcp连接完成，就会从半连接队列拷贝sock到连接队列，这个时候我们就可以唤醒阻塞的accept了。ok，我们来看关键的代码，首先是tcp_v4_do_rcv：
if (sk->sk_state == TCP_LISTEN) { struct sock *nsk = tcp_v4_hnd_req(sk, skb); if (!nsk) goto discard; if (nsk != sk) { if (tcp_child_process(sk, nsk, skb)) { rsk = nsk; goto reset; } return 0; } }
这段代码就是从半连接队列拷贝到连接队列的过程。这里我们只需要看tcp_child_process。这个函数用来处理新建的子socket。
int tcp_child_process(struct sock *parent, struct sock *child, struct sk_buff *skb){ int ret = 0; int state = child->sk_state; if (!sock_owned_by_user(child)) {///处理子socket ret = tcp_rcv_state_process(child, skb, tcp_hdr(skb), skb->len); /* Wakeup parent, send SIGIO *////关键在这里，我们可以看到这里唤醒父socket。 if (state == TCP_SYN_RECV && child->sk_state != state) parent->sk_data_ready(parent, 0); } ................................. return ret;}
我们这里看到有两个条件一个是state==TCP_SYN_RECV,另一个是child->sk_state!=state,当都满足我们就会调用sk_data_ready.然后唤醒父socket。
我们一个个来看。 这里传递进来的子套接字child，的状态我们知道是在创建新的socket的时候通过inet_csk_clone设置为TCP_SYN_RECV的，也就是当我们收到syn，并发出syn ack之后，我们再次接收到对端的数据，此时我们就新建一个socket然后设置状态为TCP_SYN_RECV. 因此这里状态必须为TCP_SYN_RECV。而当我们进入tcp_rcv_state_process处理之后，如果状态变化，哪只可能变为establish，也就是三次握手完成，因此这时的状态必须不为TCP_SYN_RECV. 因此当三次握手完毕后，我们会调用sk_data_ready通知父socket，而前一篇blog我们知道tcp中这个函数是sock_def_readable。而这个函数会调用wake_up_interruptible_sync_poll来唤醒队列。接下来我们就来看这个函数。
#define wake_up_interruptible_sync_poll(x, m) \ __wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, (void *) (m))void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, void *key){.....................................///这个函数才是最终的处理函数。 __wake_up_common(q, mode, nr_exclusive, wake_flags, key); spin_unlock_irqrestore(&q->lock, flags);}
然后就是__wake_up_common函数。这里注意传递进来的第三个参数是1.
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,int nr_exclusive, int wake_flags, void *key){ wait_queue_t *curr, *next;///开始遍历。 list_for_each_entry_safe(curr, next, &q->task_list, task_list) { unsigned flags = curr->flags;///唤醒等待队列，这里可以看到如果条件都满足的话，只会唤醒一个元素的。 if (curr->func(curr, mode, wake_flags, key) &&(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive) break; }}
然后我们就来看这几个判断条件。
1 curr->func(curr, mode, wake_flags, key) 这个是注册函数的执行。 我们主要来看后两个条件。 2 flags & WQ_FLAG_EXCLUSIVE flags必须为EXCLUSIVE，我们还记得accept等待连接的时候注册等待队列就是设置的为EXCLUSIVE标记。 3 ！--nr_exclusive 这个值是唤醒几个exclusive的元素。而我们当可读的时候传递进来的值就是1。也就是说这个值也会为真。 因此当唤醒accept的时候，只会唤醒一个进程。在新的内核，惊群现象也已经是不存在的了。 PS:不过现在大多数服务器的设计都是fork后select监控listen的句柄。这个时候自然会被全部唤醒，然后accept，只有一个能accept到，其他都会报错。所以说对现在的服务器设计并没有多大的帮助。或者说这是新式的惊群。