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()。现在循环处于＆＃34;待机状态＆＃34;州。只有当套接字接收到某些数据或超时事件时才能唤醒它。在任何这些事件之后，循环再次检查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使用率。

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

1 个答案: