blocks|key|170252|text|如果你使用read或recv，你只需要等待一个连接。如果您有多个连接，则必须创建多个进程或线程，这是对系统资源的浪费。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|170253|使用select、poll或epoll，您可以仅用一个线程监视多个连接，并在其中任何一个具有可用的数据时得到通知，然后在相应的连接上调用read或recv。|170254|它可以无限阻塞，在给定的时间内阻塞，或者根本不阻塞，这取决于参数。|170255|entityMap^0|5|4|A|4|0|2|6|9|4|E|5|1W|4|21|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|K|$]]

If you do <code>read</code> or <code>recv</code>, you're waiting on only one connection. If you have multiple connections, you will have to create multiple processes or threads, a waste of system resource.

With <code>select</code> or <code>poll</code> or <code>epoll</code>, you can monitor multiple connections with only one thread, and get notified when any of them has data available, and then you call <code>read</code> or <code>recv</code> on the corresponding connection.

It may block infinitely, block for a given time, or not block at all, depending on the arguments.

blocks|key|1830978|text|select()接受3个套接字列表以检查三个条件(读取、写入、错误)，然后返回(通常较短，通常为空)套接字列表，这些套接字列表实际上已准备好针对这些条件进行处理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1830979|s1+=+socket.socket(socket.AF_INET,+socket.SOCK_STREAM)
s1.bind((Local_IP,+Port1))
s1.listen(5)

s2+=+socket.socket(socket.AF_INET,+socket.SOCK_STREAM)
s2.bind((Local_IP,+Port2))
s2.listen(5)

sockets_that_might_be_ready_to_read+=+[s1,s2]
sockets_that_might_be_ready_to_write_to+=+[s1,s2]
sockets_that_might_have_errors+=+[s1,s2]


([ready_to_read],+[ready_to_write],+[has_errors])++=+
+++++++select.select([sockets_that_might_be_ready_to_read],
+++++++++++++++++++++[sockets_that_might_be_ready_to_write_to],+
+++++++++++++++++++++[sockets_that_might_have_errors],++++++++++++timeout)


for+sock+in+ready_to_read:
++++c,a+=+sock.accept()
++++data+=+sock.recv(128)
++++...
for+sock+in+ready_to_write:
++++#process+writes
++++...
for+sock+in+has_errors:
++++#process+errors|code-block|syntax|javascript|1830980|因此，如果一个套接字在等待超时秒后没有尝试连接，那么列表ready_to_read将为空--此时，accept()和recv()是否阻塞都无关紧要--它们不会被调用为空的列表……|1830981|如果套接字准备好读取，那么If就会有数据，所以它也不会阻塞。|1830982|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

select() takes in 3 lists of sockets to check for three conditions (read, write, error), then returns (usually shorter, often empty) lists of sockets that actually are ready to be processed for those conditions. 

<pre><code>s1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s1.bind((Local_IP, Port1))
s1.listen(5)

s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s2.bind((Local_IP, Port2))
s2.listen(5)

sockets_that_might_be_ready_to_read = [s1,s2]
sockets_that_might_be_ready_to_write_to = [s1,s2]
sockets_that_might_have_errors = [s1,s2]


([ready_to_read], [ready_to_write], [has_errors]) = 
 select.select([sockets_that_might_be_ready_to_read],
 [sockets_that_might_be_ready_to_write_to], 
 [sockets_that_might_have_errors], timeout)


for sock in ready_to_read:
 c,a = sock.accept()
 data = sock.recv(128)
 ...
for sock in ready_to_write:
 #process writes
 ...
for sock in has_errors:
 #process errors
</code></pre>

So if a socket has no attempted connections after waiting timeout seconds, then the list ready_to_read will be empty - at which point it doesn't matter if the accept() and recv() would block - they won't get called for the empty list.... 

If a socket is ready to read, then if will have data, so it won't block then, either.

blocks|key|1831004|text|好的，一次一个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1831005|这些是用来做什么的？|1831006|下面是一个简单的socket服务器框架：|1831007|s_sock+=+socket.socket()
s_sock.bind()
s_sock.listen()

while+True:
++++c_sock,+c_addr+=+s_sock.accept()
++++process_client_sock(c_sock,+c_addr)|code-block|syntax|javascript|1831008|服务器将循环并接受来自客户端的连接，然后调用其进程函数与客户端套接字进行通信。这里有一个问题：process_client_sock+可能需要很长时间，甚至包含一个循环(通常是这样)。|offset|length|style|BOLD|CODE|1831009|def+process_client_sock(c_sock,+c_addr):
++++while+True:
++++++++receive_or_send_data(c_sock)|1831010|在这种情况下，服务器不能接受更多的连接。|1831011|一个简单的解决方案是使用多进程或多线程，只需创建一个新线程来处理请求，而主循环一直在侦听新的连接。|1831012|s_sock+=+socket.socket()
s_sock.bind()
s_sock.listen()

while+True:
++++c_sock,+c_addr+=+s_sock.accept()
++++thread+=+Thread(target=process_client_sock,+args=(c_sock,+c_addr))
++++thread.start()|1831013|这当然是可行的，但考虑到性能还不够好。因为新的进程/线程需要额外的CPU和内存，所以没有空闲的服务器可能会获得数千个连接。|1831014|因此，select和poll系统调用试图解决这个问题。您为select提供了一组文件描述符，并告诉它在任何fd准备好读/写/或发生异常时通知您。|1831015|它(Select)在查看资源时会阻塞吗？|1831016|“是”或“否”取决于传递给它的参数。|1831017|正如select+man+page所说，它将获取struct+timeval参数|1831018|int+select(int+nfds,+fd_set+*readfds,+fd_set+*writefds,
+++++++fd_set+*exceptfds,+struct+timeval+*timeout);

struct+timeval+{
long++++tv_sec;+++++++++/*+seconds+*/
long++++tv_usec;++++++++/*+microseconds+*/
};|1831019|有三种情况：|1831020|1831021|timeout.tv_sec+==+0和timeout.tv_usec+=0|ordered-list-item|1831022|1831023|No-阻塞，返回immediately|1831024|timeout+==+NULL|unordered-list-item|1831025|1831026|在文件描述符为ready.|1831027|timeout之前永远阻塞是正常的|1831028|1831029|等待一段时间，如果仍然没有可用的文件描述符，则超时并返回。|1831030|轮询的目的是什么？|1831031|简单地说:在等待IO时，轮询将释放CPU用于其他工作。|1831032|这是基于一个简单的事实：|1831033|1831034|CPU比IO|1831035|waiting快得多，因为IO非常浪费时间，因为在大多数情况下，CPU都是idle|1831036|1831037|希望能有所帮助。|1831038|entityMap|0|LINK|mutability|MUTABLE|url|http://linux.die.net/man/2/select^0|0|0|0|0|1B|J|1V|O|1B|J|0|0|0|0|0|0|3|6|A|4|T|6|0|0|0|O|E|2|F|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|C|F|0|0|C|0|0|0|6|0|0|15|0|0|0|8|0^^$0|@$1|2|3|4|5|6|7|2H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|2J|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|2K|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|2L|8|@$M|2M|N|2N|O|P]|$M|2O|N|2P|O|P]|$M|2Q|N|2R|O|Q]]|9|@]|A|$]]|$1|R|3|S|5|H|7|2S|8|@]|9|@]|A|$I|J]]|$1|T|3|U|5|6|7|2T|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|2U|8|@]|9|@]|A|$]]|$1|X|3|Y|5|H|7|2V|8|@]|9|@]|A|$I|J]]|$1|Z|3|10|5|6|7|2W|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|2X|8|@$M|2Y|N|2Z|O|Q]|$M|30|N|31|O|Q]|$M|32|N|33|O|Q]]|9|@]|A|$]]|$1|13|3|14|5|6|7|34|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|35|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|36|8|@$M|37|N|38|O|Q]]|9|@$M|39|N|3A|1|3B]]|A|$]]|$1|19|3|1A|5|H|7|3C|8|@]|9|@]|A|$I|J]]|$1|1B|3|1C|5|6|7|3D|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|3E|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|1G|7|3F|8|@]|9|@]|A|$]]|$1|1H|3|-4|5|6|7|3G|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|3H|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|1M|7|3I|8|@]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|3J|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|3K|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|1M|7|3L|8|@]|9|@]|A|$]]|$1|1S|3|-4|5|6|7|3M|8|@]|9|@]|A|$]]|$1|1T|3|1U|5|6|7|3N|8|@]|9|@]|A|$]]|$1|1V|3|1W|5|6|7|3O|8|@]|9|@]|A|$]]|$1|1X|3|1Y|5|6|7|3P|8|@$M|3Q|N|3R|O|P]]|9|@]|A|$]]|$1|1Z|3|20|5|6|7|3S|8|@$M|3T|N|3U|O|P]]|9|@]|A|$]]|$1|21|3|-4|5|6|7|3V|8|@]|9|@]|A|$]]|$1|22|3|23|5|1G|7|3W|8|@$M|3X|N|3Y|O|P]]|9|@]|A|$]]|$1|24|3|25|5|1G|7|3Z|8|@$M|40|N|41|O|P]]|9|@]|A|$]]|$1|26|3|-4|5|6|7|42|8|@]|9|@]|A|$]]|$1|27|3|28|5|6|7|43|8|@$M|44|N|45|O|P]]|9|@]|A|$]]|$1|29|3|-4|5|6|7|46|8|@]|9|@]|A|$]]]|2A|$2B|$5|2C|2D|2E|A|$2F|2G]]]]

Okay, one question a time.

<h2>What are those for?</h2>

Here is a simple socket server skeleton:

<pre><code>s_sock = socket.socket()
s_sock.bind()
s_sock.listen()

while True:
 c_sock, c_addr = s_sock.accept()
 process_client_sock(c_sock, c_addr)
</code></pre>

Server will loop and accept connection from a client, then call its process function to communicate with client socket. There is a problem here: <code>process_client_sock</code> might takes a long time, or even contains a loop(which is often the case). 

<pre><code>def process_client_sock(c_sock, c_addr):
 while True:
 receive_or_send_data(c_sock)
</code></pre>

In which case, the server is unable to accept any more connections.

A simple solution would be using multi-process or multi-thread, just create a new thread to deal with request, while the main loop keeps listening on new connections.

<pre><code>s_sock = socket.socket()
s_sock.bind()
s_sock.listen()

while True:
 c_sock, c_addr = s_sock.accept()
 thread = Thread(target=process_client_sock, args=(c_sock, c_addr))
 thread.start()
</code></pre>

This works of course, but not well enough considering performance. Because new process/thread takes extra CPU and memory, not idle for servers might get thousands connections.

So <code>select</code> and <code>poll</code> system calls tries to solve this problem. You give <code>select</code> a set of file descriptors and tell it to notify you if any fd is ready to read/write/ or exception happens.

<h2>does it(select) block while watching a resource?</h2>

Yes, or no depends on the parameter you passed to it.

As <a href="http://linux.die.net/man/2/select" rel="noreferrer">select man page</a> says, it will get <code>struct timeval</code> parameter 

<pre><code>int select(int nfds, fd_set *readfds, fd_set *writefds,
 fd_set *exceptfds, struct timeval *timeout);

struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
</code></pre>

There are three cases:

<ol>
<li>timeout.tv_sec == 0 and timeout.tv_usec = 0

No-blocking, return immediately</li>
<li>timeout == NULL

block forever until a file descriptor is ready.</li>
<li>timeout is normal

wait for certain time, if still no file descriptor is available, timeout and return.</li>
</ol>

<h2>What is the purpose of polling ?</h2>

Put it into simple words: polling frees CPU for other works when waiting for IO. 

This is based on the simple facts that 

<ol>
<li>CPU is way more faster than IO</li>
<li>waiting for IO is a waste of time, because for the most time, CPU will be idle</li>
</ol>

Hope it helps.

I'm doing some threaded asynchronous networking experiment in python, using UDP.

I'd like to understand polling and the select python module, I've never used them in C/C++.

What are those for ? I kind of understand a little select, but does it block while watching a resource ? What is the purpose of polling ?

I can't understand polling/select in python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在用python做一些线程异步网络实验，使用UDP。我想了解轮询和选择python模块，我从未在C/C++中使用过它们。这些是用来做什么的？我有点理解select，但它在查看资源时会阻塞吗？轮询的目的是什么？

问我不能理解python中的轮询/选择
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我不能理解python中的轮询/选择EN