Question

我在编写在IO缓冲区和套接字之间传输数据的线程时遇到问题。我没有任何问题让它运行，但不是我想要的方式。这是代码草图：

s = socket(...) # some connection
in_buffer = b'' # consumed by other thread
out_buffer = b'' # produced by other thread
while True:
    (r, w, x) = select([s], [s], [s])
    if r:
        in_buffer += s.recv(RECV_LIMIT)
    if w:
        sent = s.send(out_buffer)
        out_buffer = out_buffer[sent:]
    if x:
        break

这个问题是它在空闲时消耗完整的CPU。原因是套接字在大多数时间是可写的，特别是在空闲时。 select()立即返回，什么都不做，再次调用select()，什么都不做等等。有一个简单的修复，当你没有要写的东西时不要检查可写套接字：

... # dito
while True:
    if out_buffer:
        (r, w, x) = select([s], [s], [s])
    else:
        (r, w, x) = select([s], [], [s])
    ... # dito

这有效，但它有一个不同的问题：当空闲时，它会无限制地阻塞select()。如果我在输出缓冲区中添加一些东西，我需要以某种方式从accept()调用中唤醒线程，但是如何？为了记录，我当前的解决方法稍微改变了评估：

while True:
    (r, w, x) = select([s], [s], [s])
    if x:
        break
    elif r:
        in_buffer += s.recv(RECV_LIMIT)
    elif w:
        if out_buffer:
            sent = s.send(out_buffer)
            out_buffer = out_buffer[sent:]
        else:
            sleep(0.001)

简而言之，当真的无所事事时，请插入延迟。毫秒足以消耗1％的CPU。类似的方法是使用select()调用的超时，然后重新检查输出数据的存在。尽管如此，两种解决方案都不是很好，因为两者都有效地归结为民意调查和民意调查。那么，如何以可移植的方式编写IO线程并且不进行轮询？

注意：一种方法是添加另一个文件描述符，我将在其上创建人工流量，以便从阻塞select()调用中唤醒线程。这里的问题是select()只能在套接字上使用，而不能在例如套接字上使用。管道。或者，在MS Windows上，我可以将win32事件与套接字的状态更改相关联，并将另一个事件与唤醒线程相关联（请参阅WSAEventSelect），但我不想将此代码写在不可移植的WinSock之上API也是。

Answer 1

我有点不清楚为什么你需要让这个中间人在这里与select合作 - 这是你问题的约束吗？在我看来，如果它是，那么你必须将输出缓冲区视为需要准备好阅读的资源，然后你才能告诉select你有兴趣写作。

如果您使用Queues传递的小字符串切换缓冲区，这似乎会大大简化。这样，您可以有两个与套接字交互的线程：

# One Thread consuming the socket
while True:
    (r, w, x) = select([s], [], [s])
    if r:
        in_buffer.put(s.recv(RECV_LIMIT))
    if x:
        break

# And one Thread writing to the socket
while True:
    string = out_buffer.get()
    (r, w, x) = select([], [s], [s])
    if w:
        s.send(string)
    if x:
        break

通过这种方式，生产线程可以安全地发信号通知数据甚至可以写入。也就是说，select是一个非常低级的接口（就像socket一样），我会考虑使用一种知道更多花俏的抽象。我偏爱gevent，但当然它面向IO绑定的应用程序，如果你受CPU限制可能不适合。在那里，生产者和消费者可以直接与套接字进行有效的交互，从而消除了对这个中间人的需求：

import gevent
from gevent import socket, sleep

def producer(sock):
    # We'll spit out some bytes every so often
    while True:
        sock.send('Hello from the producer!')
        sleep(0.01)

def consumer(sock):
    # We'll read some in as long as we can
    buffer = ''
    while True:
        buffer += sock.recv(100)
        # If the buffer can be consumed, we'll consume it and reset
        if len(buffer) > 500:
            print 'Consuming buffer: %s' % buffer
            buffer = ''

def client(sock):
    # This will emulate a client that prints what it recieves, but always
    # sends the same message
    while True:
        sock.send('Hello from the client!')
        print sock.recv(100)

# Run this to get the server going
listener = socket.socket()
listener.bind(('127.0.0.1', 5001))
listener.listen(5)
(sock, addr) = listener.accept()
gevent.joinall([
    gevent.spawn(producer, sock),
    gevent.spawn(consumer, sock)
])

# Run this to get a client going
connector = socket.socket()
connector.connect(('127.0.0.1', 5001))
gevent.joinall([
    gevent.spawn(client, connector)
])

没有轮询的基于选择的套接字循环

1 个答案: