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

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

西陵网站制作公司哪家好，找创新互联！从网页设计、网站建设、微信开发、APP开发、响应式网站建设等网站项目制作，到程序开发，运营维护。创新互联公司2013年成立到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联。

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

 
 
 
 
    
  
  
  
  
  1. SO_REUSEPORT (since Linux 3.9)
    2. 
  
  
  
  
  2.       Permits multiple AF_INET or AF_INET6 sockets to be bound to an
    3. 
  
  
  
  
  3.       identical socket address.  This option must be set on each
    4. 
  
  
  
  
  4.       socket (including the first socket) prior to calling bind(2)
    5. 
  
  
  
  
  5.       on the socket.  To prevent port hijacking, all of the pro‐
    6. 
  
  
  
  
  6.       cesses binding to the same address must have the same effec‐
    7. 
  
  
  
  
  7.       tive UID.  This option can be employed with both TCP and UDP
    8. 
  
  
  
  
  8.       sockets.
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.       For TCP sockets, this option allows accept(2) load distribu‐
    11. 
  
  
  
  
  11.       tion in a multi-threaded server to be improved by using a dis‐
    12. 
  
  
  
  
  12.       tinct listener socket for each thread.  This provides improved
    13. 
  
  
  
  
  13.       load distribution as compared to traditional techniques such
    14. 
  
  
  
  
  14.       using a single accept(2)ing thread that distributes connec‐
    15. 
  
  
  
  
  15.       tions, or having multiple threads that compete to accept(2)
    16. 
  
  
  
  
  16.       from the same socket.
    17. 
  
  
  
  
  17. 
  
  
  
  
  18.       For UDP sockets, the use of this option can provide better
    19. 
  
  
  
  
  19.       distribution of incoming datagrams to multiple processes (or
    20. 
  
  
  
  
  20.       threads) as compared to the traditional technique of having
    21. 
  
  
  
  
  21.       multiple processes compete to receive datagrams on the same
    22. 
  
  
  
  
  22.       socket.
    23.

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

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

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

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2. #include 
    3. 
  
  
  
  
  3. #include 
    4. 
  
  
  
  
  4. #include 
    5. 
  
  
  
  
  5. #include 
    6. 
  
  
  
  
  6. #include 
    7. 
  
  
  
  
  7. #include 
    8. 
  
  
  
  
  8. #include 
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. static int tcp_listen(char *ip, int port) {
    11. 
  
  
  
  
  11.   int lfd, opt, err;
    12. 
  
  
  
  
  12.   struct sockaddr_in addr;
    13. 
  
  
  
  
  13. 
  
  
  
  
  14.   lfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    15. 
  
  
  
  
  15.   assert(lfd != -1);
    16. 
  
  
  
  
  16. 
  
  
  
  
  17.   opt = 1;
    18. 
  
  
  
  
  18.   err = setsockopt(lfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
    19. 
  
  
  
  
  19.   assert(!err);
    20. 
  
  
  
  
  20. 
  
  
  
  
  21.   bzero(&addr, sizeof(addr));
    22. 
  
  
  
  
  22.   addr.sin_family = AF_INET;
    23. 
  
  
  
  
  23.   addr.sin_addr.s_addr = inet_addr(ip);
    24. 
  
  
  
  
  24.   addr.sin_port = htons(port);
    25. 
  
  
  
  
  25. 
  
  
  
  
  26.   err = bind(lfd, (struct sockaddr *)&addr, sizeof(addr));
    27. 
  
  
  
  
  27.   assert(!err);
    28. 
  
  
  
  
  28. 
  
  
  
  
  29.   err = listen(lfd, 8);
    30. 
  
  
  
  
  30.   assert(!err);
    31. 
  
  
  
  
  31. 
  
  
  
  
  32.   return lfd;
    33. 
  
  
  
  
  33. }
    34. 
  
  
  
  
  34. 
  
  
  
  
  35. int main(int argc, char *argv[]) {
    36. 
  
  
  
  
  36.   int lfd, sfd;
    37. 
  
  
  
  
  37. 
  
  
  
  
  38.   lfd = tcp_listen("127.0.0.1", 8888);
    39. 
  
  
  
  
  39.   while (1) {
    40. 
  
  
  
  
  40.     sfd = accept(lfd, NULL, NULL);
    41. 
  
  
  
  
  41.     close(sfd);
    42. 
  
  
  
  
  42.     printf("接收到tcp连接：%d\n", sfd);
    43. 
  
  
  
  
  43.   }
    44. 
  
  
  
  
  44. 
  
  
  
  
  45.   return 0;
    46. 
  
  
  
  
  46. }
    47.

编译并执行该程序：

 
 
 
 
    
  
  
  
  
  1. $ gcc server.c && ./a.out
    2.

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

 
 
 
 
    
  
  
  
  
  1. $ ss -antp | grep 8888
    2. 
  
  
  
  
  2. LISTEN       0        8              127.0.0.1:8888              0.0.0.0:*       users:(("a.out",pid=32505,fd=3))
    3.

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

我们再执行一次该程序：

 
 
 
 
    
  
  
  
  
  1. $ gcc server.c && ./a.out
    2.

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

 
 
 
 
    
  
  
  
  
  1. $ ss -antp | grep 8888
    2. 
  
  
  
  
  2. LISTEN     0        8               127.0.0.1:8888               0.0.0.0:*       users:(("a.out",pid=32607,fd=3))
    3. 
  
  
  
  
  3. LISTEN     0        8               127.0.0.1:8888               0.0.0.0:*       users:(("a.out",pid=32505,fd=3))
    4.

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

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

 
 
 
 
    
  
  
  
  
  1. $ ncat localhost 8888
    2.

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

服务端1：

 
 
 
 
    
  
  
  
  
  1. $ gcc server.c && ./a.out
    2. 
  
  
  
  
  2. 接收到tcp连接：4
    3. 
  
  
  
  
  3. 接收到tcp连接：4
    4. 
  
  
  
  
  4. 接收到tcp连接：4
    5.

服务端2:

 
 
 
 
    
  
  
  
  
  1. $ gcc server.c && ./a.out
    2. 
  
  
  
  
  2. 接收到tcp连接：4
    3. 
  
  
  
  
  3. 接收到tcp连接：4
    4.

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

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

 
 
 
 
    
  
  
  
  
  1. // net/ipv4/inet_connection_sock.c
    2. 
  
  
  
  
  2. int inet_csk_get_port(struct sock *sk, unsigned short snum)
    3. 
  
  
  
  
  3. {
    4. 
  
  
  
  
  4.         ...
    5. 
  
  
  
  
  5.         struct inet_hashinfo *hinfo = sk->sk_prot->h.hashinfo;
    6. 
  
  
  
  
  6.         int ret = 1, port = snum;
    7. 
  
  
  
  
  7.         struct inet_bind_hashbucket *head;
    8. 
  
  
  
  
  8.         ...
    9. 
  
  
  
  
  9.         struct inet_bind_bucket *tb = NULL;
    10. 
  
  
  
  
  10.         ...
    11. 
  
  
  
  
  11.         head = &hinfo->bhash[inet_bhashfn(net, port,
    12. 
  
  
  
  
  12.                                           hinfo->bhash_size)];
    13. 
  
  
  
  
  13.         ...
    14. 
  
  
  
  
  14.         inet_bind_bucket_for_each(tb, &head->chain)
    15. 
  
  
  
  
  15.                 if (net_eq(ib_net(tb), net) && tb->l3mdev == l3mdev &&
    16. 
  
  
  
  
  16.                     tb->port == port)
    17. 
  
  
  
  
  17.                         goto tb_found;
    18. 
  
  
  
  
  18. tb_not_found:
    19. 
  
  
  
  
  19.         tb = inet_bind_bucket_create(hinfo->bind_bucket_cachep,
    20. 
  
  
  
  
  20.                                      net, head, port, l3mdev);
    21. 
  
  
  
  
  21.         ...
    22. 
  
  
  
  
  22. tb_found:
    23. 
  
  
  
  
  23.         if (!hlist_empty(&tb->owners)) {
    24. 
  
  
  
  
  24.                 ...
    25. 
  
  
  
  
  25.                 if (... || sk_reuseport_match(tb, sk))
    26. 
  
  
  
  
  26.                         goto success;
    27. 
  
  
  
  
  27.                 ...
    28. 
  
  
  
  
  28.         }
    29. 
  
  
  
  
  29. success:
    30. 
  
  
  
  
  30.         if (hlist_empty(&tb->owners)) {
    31. 
  
  
  
  
  31.                 ...
    32. 
  
  
  
  
  32.                 if (sk->sk_reuseport) {
    33. 
  
  
  
  
  33.                         tb->fastreuseport = FASTREUSEPORT_ANY;
    34. 
  
  
  
  
  34.                         ...
    35. 
  
  
  
  
  35.                 } else {
    36. 
  
  
  
  
  36.                         tb->fastreuseport = 0;
    37. 
  
  
  
  
  37.                 }
    38. 
  
  
  
  
  38.         } else {
    39. 
  
  
  
  
  39.                 ...
    40. 
  
  
  
  
  40.         }
    41. 
  
  
  
  
  41.         ...
    42. 
  
  
  
  
  42. }
    43. 
  
  
  
  
  43. EXPORT_SYMBOL_GPL(inet_csk_get_port);
    44.

当我们做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方法：

 
 
 
 
    
  
  
  
  
  1. // net/ipv4/inet_connection_sock.c
    2. 
  
  
  
  
  2. static inline int sk_reuseport_match(struct inet_bind_bucket *tb,
    3. 
  
  
  
  
  3.                                      struct sock *sk)
    4. 
  
  
  
  
  4. {
    5. 
  
  
  
  
  5.         ...
    6. 
  
  
  
  
  6.         if (tb->fastreuseport <= 0)
    7. 
  
  
  
  
  7.                 return 0;
    8. 
  
  
  
  
  8.         if (!sk->sk_reuseport)
    9. 
  
  
  
  
  9.                 return 0;
    10. 
  
  
  
  
  10.         ...
    11. 
  
  
  
  
  11.         if (tb->fastreuseport == FASTREUSEPORT_ANY)
    12. 
  
  
  
  
  12.                 return 1;
    13. 
  
  
  
  
  13.         ...
    14. 
  
  
  
  
  14. }
    15.

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

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

 
 
 
 
    
  
  
  
  
  1. // net/core/sock_reuseport.c
    2. 
  
  
  
  
  2. int reuseport_add_sock(struct sock *sk, struct sock *sk2, bool bind_inany)
    3. 
  
  
  
  
  3. {
    4. 
  
  
  
  
  4.         struct sock_reuseport *old_reuse, *reuse;
    5. 
  
  
  
  
  5.         ...
    6. 
  
  
  
  
  6.         reuse = rcu_dereference_protected(sk2->sk_reuseport_cb,
    7. 
  
  
  
  
  7.                                           lockdep_is_held(&reuseport_lock));
    8. 
  
  
  
  
  8.         ...
    9. 
  
  
  
  
  9.         reuse->socks[reuse->num_socks] = sk;
    10. 
  
  
  
  
  10.         ...
    11. 
  
  
  
  
  11.         reuse->num_socks++;
    12. 
  
  
  
  
  12.         rcu_assign_pointer(sk->sk_reuseport_cb, reuse);
    13. 
  
  
  
  
  13.         ...
    14. 
  
  
  
  
  14. }
    15. 
  
  
  
  
  15. EXPORT_SYMBOL(reuseport_add_sock);
    16.

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上了。

看下相应代码：

 
 
 
 
    
  
  
  
  
  1. // net/core/sock_reuseport.c
    2. 
  
  
  
  
  2. struct sock *reuseport_select_sock(struct sock *sk,
    3. 
  
  
  
  
  3.                                    u32 hash,
    4. 
  
  
  
  
  4.                                    struct sk_buff *skb,
    5. 
  
  
  
  
  5.                                    int hdr_len)
    6. 
  
  
  
  
  6. {
    7. 
  
  
  
  
  7.         struct sock_reuseport *reuse;
    8. 
  
  
  
  
  8.         ...
    9. 
  
  
  
  
  9.         struct sock *sk2 = NULL;
    10. 
  
  
  
  
  10.         u16 socks;
    11. 
  
  
  
  
  11.         ...
    12. 
  
  
  
  
  12.         reuse = rcu_dereference(sk->sk_reuseport_cb);
    13. 
  
  
  
  
  13.         ...
    14. 
  
  
  
  
  14.         socks = READ_ONCE(reuse->num_socks);
    15. 
  
  
  
  
  15.         if (likely(socks)) {
    16. 
  
  
  
  
  16.                 ...
    17. 
  
  
  
  
  17.                 if (!sk2)
    18. 
  
  
  
  
  18.                         sk2 = reuse->socks[reciprocal_scale(hash, socks)];
    19. 
  
  
  
  
  19.         }
    20. 
  
  
  
  
  20.         ...
    21. 
  
  
  
  
  21.         return sk2;
    22. 
  
  
  
  
  22. }
    23. 
  
  
  
  
  23. EXPORT_SYMBOL(reuseport_select_sock);
    24.

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

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

 
 
 
 
    
  
  
  
  
  1. // include/linux/kernel.h
    2. 
  
  
  
  
  2. /**
    3. 
  
  
  
  
  3.  * reciprocal_scale - "scale" a value into range [0, ep_ro)
    4. 
  
  
  
  
  4.  * ...
    5. 
  
  
  
  
  5.  */
    6. 
  
  
  
  
  6. static inline u32 reciprocal_scale(u32 val, u32 ep_ro)
    7. 
  
  
  
  
  7. {
    8. 
  
  
  
  
  8.         return (u32)(((u64) val * ep_ro) >> 32);
    9. 
  
  
  
  
  9. }
    10.

算法虽然我们看不懂，但通过其注释我们可以知道，它返回的值的区间是[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什么的完全不是问题。

好，就到这里吧。

本文转载自微信公众号「卯时卯刻」，可以通过以下二维码关注。转载本文请联系卯时卯刻公众号。

网站题目：多进程可以监听同一端口吗
本文URL：http://www.shufengxianlan.com/qtweb/news42/49442.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

解决方案知识

行业网站建设

四川乐山服务器托管　　 　甘孜州博瑞斯　　 　四川主机托管　　 　橡塑保温材料　　 　泸州网站建设　　 　企业邮箱　　 　乐山托管服务器　　 　雕琢时光　　 　百度推广公司　　 　成都枢纽中心　　 　成都发电机维修　　 　LED亮化工程　　 　小程序开发　　 　做网站　　 　关键词优化排名　　 　成都棕数机房　　 　小谭网创广告　　 　手机软件开发　　 　化妆品企业网站建设方案　　 　网站空间