云锦诚建站，专注安岳网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
当然可以，只要你使用 SO_REUSEPORT 这个参数。
西陵网站制作公司哪家好，找创新互联！从网页设计、网站建设、微信开发、APP开发、响应式网站建设等网站项目制作，到程序开发，运营维护。创新互联公司2013年成立到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联。
还是先来看下man文档中是怎么说的：
- SO_REUSEPORT (since Linux 3.9)
- Permits multiple AF_INET or AF_INET6 sockets to be bound to an
- identical socket address. This option must be set on each
- socket (including the first socket) prior to calling bind(2)
- on the socket. To prevent port hijacking, all of the pro‐
- cesses binding to the same address must have the same effec‐
- tive UID. This option can be employed with both TCP and UDP
- sockets.
- For TCP sockets, this option allows accept(2) load distribu‐
- tion in a multi-threaded server to be improved by using a dis‐
- tinct listener socket for each thread. This provides improved
- load distribution as compared to traditional techniques such
- using a single accept(2)ing thread that distributes connec‐
- tions, or having multiple threads that compete to accept(2)
- from the same socket.
- For UDP sockets, the use of this option can provide better
- distribution of incoming datagrams to multiple processes (or
- threads) as compared to the traditional technique of having
- multiple processes compete to receive datagrams on the same
- socket.
从文档中可以看到，该参数允许多个socket绑定到同一本地地址，即使socket是处于listen状态的。
当多个listen状态的socket绑定到同一地址时，各个socket的accept操作都能接受到新的tcp连接。
很神奇对吧，写段代码测试下：
- #include
- #include
- #include
- #include
- #include
- #include
- #include
- #include
- static int tcp_listen(char *ip, int port) {
- int lfd, opt, err;
- struct sockaddr_in addr;
- 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, (struct sockaddr *)&addr, sizeof(addr));
- assert(!err);
- err = listen(lfd, 8);
- assert(!err);
- return lfd;
- }
- int main(int argc, char *argv[]) {
- int lfd, sfd;
- lfd = tcp_listen("127.0.0.1", 8888);
- while (1) {
- sfd = accept(lfd, NULL, NULL);
- close(sfd);
- printf("接收到tcp连接：%d\n", sfd);
- }
- return 0;
- }
编译并执行该程序：
- $ gcc server.c && ./a.out
看下当前8888端口的所有socket的状态：
- $ ss -antp | grep 8888
- LISTEN 0 8 127.0.0.1:8888 0.0.0.0:* users:(("a.out",pid=32505,fd=3))
和我们预想的一样，只有一个socket处于listen状态。
我们再执行一次该程序：
- $ gcc server.c && ./a.out
再次查看8888端口socket的状态：
- $ ss -antp | grep 8888
- LISTEN 0 8 127.0.0.1:8888 0.0.0.0:* users:(("a.out",pid=32607,fd=3))
- LISTEN 0 8 127.0.0.1:8888 0.0.0.0:* users:(("a.out",pid=32505,fd=3))
此时已经出现两个socket在监听8888端口(注意它们的ip地址也是一样的)，而这两个socket分别属于两个进程。
我们现在再用ncat模拟客户端，连接8888端口：
- $ ncat localhost 8888
重复该操作，建立n个到8888端口的tcp连接，此时两个服务端终端的输出如下。
服务端1：
- $ gcc server.c && ./a.out
- 接收到tcp连接：4
- 接收到tcp连接：4
- 接收到tcp连接：4
服务端2:
- $ gcc server.c && ./a.out
- 接收到tcp连接：4
- 接收到tcp连接：4
可以看到，tcp连接基本上算是均匀分布到两个服务器上，神奇。
下面我们来看到对应的linux内核代码，看看它是如何实现的。
- // net/ipv4/inet_connection_sock.c
- int inet_csk_get_port(struct sock *sk, unsigned short snum)
- {
- ...
- struct inet_hashinfo *hinfo = sk->sk_prot->h.hashinfo;
- int ret = 1, port = snum;
- struct inet_bind_hashbucket *head;
- ...
- struct inet_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)
- goto tb_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))
- goto success;
- ...
- }
- 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
- static inline int sk_reuseport_match(struct inet_bind_bucket *tb,
- struct sock *sk)
- {
- ...
- if (tb->fastreuseport <= 0)
- return 0;
- if (!sk->sk_reuseport)
- return 0;
- ...
- if (tb->fastreuseport == FASTREUSEPORT_ANY)
- return 1;
- ...
- }
由于上一次listen操作，tb->fastreuseport被设置为FASTREUSEPORT_ANY，而此次listen操作的socket，又设置了SO_REUSEPORT参数，即sk->sk_reuseport值大于0，所以，该方法最终返回true。
由上可见，设置了SO_REUSEPORT参数之后，第二次listen中的bind操作是没用问题的，我们再看下对应的listen操作：
- // net/core/sock_reuseport.c
- int reuseport_add_sock(struct sock *sk, struct sock *sk2, bool bind_inany)
- {
- struct sock_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
- struct sock *reuseport_select_sock(struct sock *sk,
- u32 hash,
- struct sk_buff *skb,
- int hdr_len)
- {
- struct sock_reuseport *reuse;
- ...
- struct sock *sk2 = NULL;
- u16 socks;
- ...
- 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)];
- }
- ...
- return sk2;
- }
- EXPORT_SYMBOL(reuseport_select_sock);
看到了吧，该方法中，最后使用了reciprocal_scale方法，计算被选中的listen socket的索引，最后返回这个listen socket继续处理tcp连接请求。
看下reciprocal_scale方法是如何实现的：
- // include/linux/kernel.h
- /**
- * reciprocal_scale - "scale" a value into range [0, ep_ro)
- * ...
- */
- static inline u32 reciprocal_scale(u32 val, u32 ep_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什么的完全不是问题。
好，就到这里吧。
本文转载自微信公众号「卯时卯刻」，可以通过以下二维码关注。转载本文请联系卯时卯刻公众号。