python - 在 asyncore 客户端中定义可写方法使发送数据非常慢

Question

我使用 python asyncore 编写了一个异步客户端，遇到了一些问题。我已经在这个帮助下解决了这个问题:

Asyncore client in thread makes the whole program crash when sending data immediately

但现在我遇到了一些其他问题。

我的客户端程序:

import asyncore, threading, socket
class Client(threading.Thread, asyncore.dispatcher):
    def __init__(self, host, port):
        threading.Thread.__init__(self)
        self.daemon = True
        self._thread_sockets = dict()
        asyncore.dispatcher.__init__(self, map=self._thread_sockets)
        self.host = host
        self.port = port
        self.output_buffer = []
        self.start()

    def send(self, msg):
        self.output_buffer.append(msg)
    def writable(self):
        return len("".join(self.output_buffer)) > 0
    def handle_write(self):
        all_data = "".join(self.output_buffer)
        bytes_sent = self.socket.send(all_data)
        remaining_data = all_data[bytes_sent:]
        self.output_buffer = [remaining_data]
    def handle_close(self):
        self.close()
    def handle_error(self):
        print("error")
    def handle_read(self):
        print(self.recv(10))
    def run(self):
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.connect((self.host, self.port))
        asyncore.loop(map = self._thread_sockets)

mysocket = Client("127.0.0.1",8400)
while True:
    a=str(input("input"))
    mysocket.send("popo")

还有我的服务器程序:

import socket
HOST="127.0.0.1"
PORT=8400
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("socket created")
s.bind((HOST, PORT))
s.listen(1)
print("listen")
conn,addr = s.accept()
print("Accepted. Receiving")
while True:
    data = conn.recv(20)
    print("Received: ")
    print(data)
    data = input("Please input reply message:\n").encode("utf-8")
    conn.send(data)
    print("Data sended. Receiving")

我的问题是从客户端向服务器发送数据非常慢，大约需要 20 到 30 秒!但它始终可以成功发送数据。如果我在客户端注释掉可写方法，发送过程就会变得非常快。为什么它会这样？如果我想使用可写方法如何修复它？谢谢!

我用 python3 启动服务器，用 python 2 启动客户端。我使用 ubuntu 14.04。

Answer 1

asyncore 循环在准备好对套接字执行某些操作时调用writable()。如果方法 writable() 告诉有东西要写然后 handle_write() 被调用。默认的 writable() 总是返回 True，所以在这种情况下会出现忙循环调用 handle_write() 和 writable().

在上面的实现中，当客户端循环开始时，方法writable() 被立即调用。在那一刻缓冲区中没有任何内容，所以 writable() 告诉没有什么可写的。

asyncore 循环调用 select()。现在循环处于“待机”状态。它只能在套接字或超时事件接收到某些数据时被唤醒。在任何这些事件之后，循环再次检查 writable()。

服务器不向客户端发送任何内容，客户端等待超时。默认的 timeout 是 30 秒，所以这就是为什么在发送某些东西之前需要等待最多 30 秒的原因。可以减少启动 asyncore.loop() 期间的超时:

    asyncore.loop(map = self._thread_sockets, timeout = 0.5)

---

这里可能出现的另一个想法是在 send() 中检查缓冲区是否为空，如果为空则立即发送。但是，这是一个坏主意。 send() 在主线程中调用，但套接字由另一个线程中的 asyncore 循环管理。

出于同样的原因，保护 output_buffer 的使用对于不同线程的并发访问是有意义的。锁对象 threading.Lock() 可以在这里使用:

def __init__(self, host, port):
    #...
    self.lock = threading.Lock()

def send(self, msg):
    self.lock.acquire()
    try:
        self.output_buffer.append(msg)
    finally:
        self.lock.release()

def writable(self):
    is_writable = False;
    self.lock.acquire()
    try:
        is_writable = len("".join(self.output_buffer)) > 0
    finally:
        self.lock.release()

    return is_writable

def handle_write(self):
    self.lock.acquire()
    try:
        all_data = "".join(self.output_buffer)
        bytes_sent = self.socket.send(all_data)
        remaining_data = all_data[bytes_sent:]
        self.output_buffer = [remaining_data]
    finally:
        self.lock.release()

没有线程安全机制可以从另一个线程唤醒asyncore。因此，唯一的解决方案是减少循环超时，尽管超时太小会增加 CPU 使用率。