多进程可以监听同一端口吗

当然可以，只要你使用 SO_REUSEPORT 这个参数。

还是先来看下man文档中是怎么说的：

SO_REUSEPORT(sinceLinux3.9)
PermitsmultipleAF_INETorAF_INET6socketstobeboundtoan
identicalsocketaddress.Thisoptionmustbesetoneach
socket(includingthefirstsocket)priortocallingbind(2)
onthesocket.Topreventporthijacking,allofthepro‐
cessesbindingtothesameaddressmusthavethesameeffec‐
tiveUID.ThisoptioncanbeemployedwithbothTCPandUDP
sockets.

ForTCPsockets,thisoptionallowsaccept(2)loaddistribu‐
tioninamulti-threadedservertobeimprovedbyusingadis‐
tinctlistenersocketforeachthread.Thisprovidesimproved
loaddistributionascomparedtotraditionaltechniquessuch
usingasingleaccept(2)ingthreadthatdistributesconnec‐
tions,orhavingmultiplethreadsthatcompetetoaccept(2)
fromthesamesocket.

ForUDPsockets,theuseofthisoptioncanprovidebetter
distributionofincomingdatagramstomultipleprocesses(or
threads)ascomparedtothetraditionaltechniqueofhaving
multipleprocessescompetetoreceivedatagramsonthesame
socket.

从文档中可以看到，该参数允许多个socket绑定到同一本地地址，即使socket是处于listen状态的。

当多个listen状态的socket绑定到同一地址时，各个socket的accept操作都能接受到新的tcp连接。

很神奇对吧，写段代码测试下：

#include<arpa/inet.h>
#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
#include<strings.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<unistd.h>

staticinttcp_listen(char*ip,intport){
intlfd,opt,err;
structsockaddr_inaddr;

lfd=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
assert(lfd!=-1);

opt=1;
err=setsockopt(lfd,SOL_SOCKET,SO_REUSEPORT,&opt,sizeof(opt));
assert(!err);

bzero(&addr,sizeof(addr));
addr.sin_family=AF_INET;
addr.sin_addr.s_addr=inet_addr(ip);
addr.sin_port=htons(port);

err=bind(lfd,(structsockaddr*)&addr,sizeof(addr));
assert(!err);

err=listen(lfd,8);
assert(!err);

returnlfd;
}

intmain(intargc,char*argv[]){
intlfd,sfd;

lfd=tcp_listen("127.0.0.1",8888);
while(1){
sfd=accept(lfd,NULL,NULL);
close(sfd);
printf("接收到tcp连接：%d\n",sfd);
}

return0;
}

编译并执行该程序：

$gccserver.c&&./a.out

看下当前8888端口的所有socket的状态：

$ss-antp|grep8888
LISTEN08127.0.0.1:88880.0.0.0:*users:(("a.out",pid=32505,fd=3))

和我们预想的一样，只有一个socket处于listen状态。

我们再执行一次该程序：

$gccserver.c&&./a.out

再次查看8888端口socket的状态：

$ss-antp|grep8888
LISTEN08127.0.0.1:88880.0.0.0:*users:(("a.out",pid=32607,fd=3))
LISTEN08127.0.0.1:88880.0.0.0:*users:(("a.out",pid=32505,fd=3))

此时已经出现两个socket在监听8888端口(注意它们的ip地址也是一样的)，而这两个socket分别属于两个进程。

我们现在再用ncat模拟客户端，连接8888端口：

$ncatlocalhost8888

重复该操作，建立n个到8888端口的tcp连接，此时两个服务端终端的输出如下。

服务端1：

$gccserver.c&&./a.out
接收到tcp连接：4
接收到tcp连接：4
接收到tcp连接：4

服务端2:

$gccserver.c&&./a.out
接收到tcp连接：4
接收到tcp连接：4

可以看到，tcp连接基本上算是均匀分布到两个服务器上，神奇。

下面我们来看到对应的linux内核代码，看看它是如何实现的。

//net/ipv4/inet_connection_sock.c
intinet_csk_get_port(structsock*sk,unsignedshortsnum)
{
...
structinet_hashinfo*hinfo=sk->sk_prot->h.hashinfo;
intret=1,port=snum;
structinet_bind_hashbucket*head;
...
structinet_bind_bucket*tb=NULL;
...
head=&hinfo->bhash[inet_bhashfn(net,port,
hinfo->bhash_size)];
...
inet_bind_bucket_for_each(tb,&head->chain)
if(net_eq(ib_net(tb),net)&&tb->l3mdev==l3mdev&&
tb->port==port)
gototb_found;
tb_not_found:
tb=inet_bind_bucket_create(hinfo->bind_bucket_cachep,
net,head,port,l3mdev);
...
tb_found:
if(!hlist_empty(&tb->owners)){
...
if(...||sk_reuseport_match(tb,sk))
gotosuccess;
...
}
success:
if(hlist_empty(&tb->owners)){
...
if(sk->sk_reuseport){
tb->fastreuseport=FASTREUSEPORT_ANY;
...
}else{
tb->fastreuseport=0;
}
}else{
...
}
...
}
EXPORT_SYMBOL_GPL(inet_csk_get_port);

当我们做bind等操作时，就会调用这个方法，参数snum就是我们要bind的端口。

该方法中，类型struct inet_bind_bucket代表端口bind的具体信息，比如：哪个socket在bind这个端口。

hinfo->bhash是用于存放struct inet_bind_bucket实例的hashmap。

该方法先从hinfo->bhash这个hashmap中找，该端口是否已经被bind过，如果没有，则新创建一个tb，比如我们第一次listen操作时，该端口就没有被使用，所以会新创建一个tb。

新创建的tb，它的tb->owners是empty，此时，如果我们设置了SO_REUSEPORT参数，那sk->sk_reuseport字段值就会大于0，也就是说，第一次listen操作之后，tb->fastreuseport的值被设置为FASTREUSEPORT_ANY(大于0)。

当我们第二次做listen操作时，又会进入到这个方法，此时hinfo->bhash的map中存在相同端口的tb，所以会goto到tb_found部分。

因为之前的listen操作会把其对应的socket放入到tb->owners中，所以第二次的listen操作，tb->owners不为empty。

进而，逻辑处理会进入到sk_reuseport_match方法，如果此方法返回true，则内核会允许第二次listen操作使用该本地地址。

我们看下sk_reuseport_match方法：

//net/ipv4/inet_connection_sock.c
staticinlineintsk_reuseport_match(structinet_bind_bucket*tb,
structsock*sk)
{
...
if(tb->fastreuseport<=0)
return0;
if(!sk->sk_reuseport)
return0;
...
if(tb->fastreuseport==FASTREUSEPORT_ANY)
return1;
...
}

由于上一次listen操作，tb->fastreuseport被设置为FASTREUSEPORT_ANY，而此次listen操作的socket，又设置了SO_REUSEPORT参数，即sk->sk_reuseport值大于0，所以，该方法最终返回true。

由上可见，设置了SO_REUSEPORT参数之后，第二次listen中的bind操作是没用问题的，我们再看下对应的listen操作：

//net/core/sock_reuseport.c
intreuseport_add_sock(structsock*sk,structsock*sk2,boolbind_inany)
{
structsock_reuseport*old_reuse,*reuse;
...
reuse=rcu_dereference_protected(sk2->sk_reuseport_cb,
lockdep_is_held(&reuseport_lock));
...
reuse->socks[reuse->num_socks]=sk;
...
reuse->num_socks++;
rcu_assign_pointer(sk->sk_reuseport_cb,reuse);
...
}
EXPORT_SYMBOL(reuseport_add_sock);

listen方法最终会调用上面的方法，在该方法中，sk代表第二次listen操作的socket，sk2代表第一次listen操作的socket。

该方法的大致逻辑为：

1. 将sk2->sk_reuseport_cb字段值赋值给reuse。

2. 将sk放入到reuse->socks字段代表的数组中。

3. 将sk的sk_reuseport_cb字段也指向这个数组。

也就是说，该方法会将所有第二次及其以后的listen操作的socket放入到reuse->socks字段代表的数组中(第一次listen操作的socket在创建struct sock_reuseport实例时就已经被放入到该数组中了)，同时，将所有listen的socket的sk->sk_reuseport_cb字段，都指向reuse，这样，我们就可以通过listen的socket的sk_reuseport_cb字段，拿到struct sock_reuseport实例，进而可以拿到所有其他的listen同一端口的socket。

到现在为止，reuseport是如何实现的基本就明朗了，当有新的tcp连接来时，只要我们找到监听该端口的一个listen的socket，就等于拿到了所有设置了SO_REUSEPORT参数，并监听同样端口的其他socket，我们只需随机挑一个socket，然后让它完成之后的tcp连接建立过程，这样我们就可以实现tcp连接均匀负载到这些listen socket上了。

看下相应代码：

//net/core/sock_reuseport.c
structsock*reuseport_select_sock(structsock*sk,
u32hash,
structsk_buff*skb,
inthdr_len)
{
structsock_reuseport*reuse;
...
structsock*sk2=NULL;
u16socks;
...
reuse=rcu_dereference(sk->sk_reuseport_cb);
...
socks=READ_ONCE(reuse->num_socks);
if(likely(socks)){
...
if(!sk2)
sk2=reuse->socks[reciprocal_scale(hash,socks)];
}
...
returnsk2;
}
EXPORT_SYMBOL(reuseport_select_sock);

看到了吧，该方法中，最后使用了reciprocal_scale方法，计算被选中的listen socket的索引，最后返回这个listen socket继续处理tcp连接请求。

看下reciprocal_scale方法是如何实现的：

//include/linux/kernel.h
/**
*reciprocal_scale-"scale"avalueintorange[0,ep_ro)
*...
*/
staticinlineu32reciprocal_scale(u32val,u32ep_ro)
{
return(u32)(((u64)val*ep_ro)>>32);
}

算法虽然我们看不懂，但通过其注释我们可以知道，它返回的值的区间是[0, ep_ro)，再结合上面的reuseport_select_sock方法我们可以确定，返回的就是所有listen socket的数组下标索引。

至此，有关SO_REUSEPORT参数的内容我们就讲完了。

上篇文章 socket的SO_REUSEADDR参数全面分析 中，我们分析了SO_REUSEADDR参数，那这个参数和SO_REUSEADDR又有什么区别呢?

SO_REUSEPORT参数是SO_REUSEADDR参数的超集，两个参数目的都是为了重复使用本地地址，但SO_REUSEADDR不允许处于listen状态的地址重复使用，而SO_REUSEPORT允许，同时，SO_REUSEPORT参数还会把新来的tcp连接负载均衡到各个listen socket上，为我们tcp服务器编程，提供了一种新的模式。

其实，该参数在我上次写的socks5代理那个项目就有用到(是的，我又用rust实现了一版socks5代理)，通过使用该参数，我可以开多个进程同时处理socks5代理请求，现在使用下来的感受是，真的非常快，用Google什么的完全不是问题。

好，就到这里吧。