使用 Python 进行 socket 编程

本文主要参考 https://docs.python.org/3/howto/sockets.html 。

本文只讨论 STREAME（比如 TCP） INET（比如 IPv4） socket。

在多种跨进程通信方式中，sockets 是最受欢迎的。对于任意给定的平台，有可能存在其他更快的跨进程通信方式，但对于跨平台交流，sockets 应该是唯一的一种。

创建 Socket

客户端 Socket

通俗的讲，当你点击一个链接，你的浏览器会做以下事情：

# create an INET, STREAMing socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接到服务器，如果 URL 中没有指明端口，那么端口为默认的 80
s.connect(("www.python.org", 80))

建立连接后，可以用 socket s 来发送请求。然后 s 会读取回复，然后被销毁。在一次请求-接收过程（或者一系列连续的小的过程）中，客户端 sockets 通常只会被使用一次。

服务端 Socket

对于 web 服务器来说：

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

socket.gethostname() 的地址可以被外部看到。

listen 告知 socket 库，监听队列中最多能有 5 个连接请求，队列满了之后的请求会被拒绝。

主循环

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

没有连接时 accept 会一直阻塞。

主循环通常有三种工作方式：

分派一个线程去处理 clientsocket
创建一个进程去处理 clientsocket
重构以使用非阻塞 sockets 并使用 select 在我们的服务器 socket 和 clientsocket 多路传输（multiplex）

上面的代码就是服务端 socket 所做的。它不发送、接收任何数据。它只是生产 clientsocket。每个 clientsocket 被创建出，用来响应 connect() 来的 “client” sockets（比如浏览器）。

服务端 socket 在创建 clientsocket 后，又重新返回去监听更多的连接。那两个客户端 sockets 在自由地交谈 -- 使用动态分配的并在谈话结束后会被回收的端口。

使用 Socket

作为设计者，你必须决定客户端 sockets 之间的交流规则。

send 和 recv 操作网络 buffers，它们不一定会处理所有你传递给它们的 bytes，因为它们集中于处理网络 buffers。当网络 buffers 被 send 或 recv 时，它们会返回它们处理的 bytes 数目。调用它们以确保所有数据已被处理是你的责任。

当 recv 返回 b"" 或者 send 返回 0 意味着另一边已经关闭了（或正在关闭）连接。如果是 recv ，那么你将不会从这个连接再收到任何数据，但你可能可以成功的发送数据，在下文会谈到。如果是 send，那你不能再向这个 socket 发送任何数据。

类似 HTTP 协议在一次交谈中只使用一个 socket。客户端 socket 发送请求，读取回复，然后客户端 socket 被遗弃。所以客户端可以通过接受到 0 bytes 的回复来发现交谈结束了。

如果你打算为了将来的传输复用你的 socket，你需要知道 socket 中没有传输结束（EOT）这个标识。

总结一下：如果 send 或 recv 0 bytes，那么这个连接已经被关闭了。如果一个连接没有被关闭，你可能永远在等 recv，因为 socket 不会告诉你现在并没有更多消息了。

所以信息

必须是固定长度的
或者被划定了界限
或者指出信息有多长
或者以关闭连接来结束

完全由你来选择使用何种方法。

信息长度指 send 和 recv 的信息的长度。比如 send 发送 bytes，那么是 str 转换为 bytes 后的信息的长度而不是 str 的表示的信息的长度。

最简单的方法是固定长度的消息：

class MySocket:
    """demonstration class only
      - coded for clarity, not efficiency
    """

    def __init__(self, sock=None):
        if sock is None:
            self.sock = socket.socket(
                            socket.AF_INET, socket.SOCK_STREAM)
        else:
            self.sock = sock

    def connect(self, host, port):
        self.sock.connect((host, port))

    def mysend(self, msg):
        totalsent = 0
        while totalsent < MSGLEN:
            sent = self.sock.send(msg[totalsent:])
            if sent == 0:
                raise RuntimeError("socket connection broken")
            totalsent = totalsent + sent

    def myreceive(self):
        chunks = []
        bytes_recd = 0
        while bytes_recd < MSGLEN:
            chunk = self.sock.recv(min(MSGLEN - bytes_recd, 2048))
            if chunk == b'':
                raise RuntimeError("socket connection broken")
            chunks.append(chunk)
            bytes_recd = bytes_recd + len(chunk)
        return b''.join(chunks)

长度的选择是要发送的信息的最大长度，如果信息长度不足，那么按照约定补充信息直到长度符合，约定的字符也是由你决定。

上面的代码是确保发送、接收的代码不小于定义的长度。

在发送时，由于发送的长度不固定，所以每次要从之前发送的信息之后开始发送。

接收时，要准确地指定需要接收的消息长度。如果指定长度小于实际长度，那么信息就不完整；反之，会一直等待信息发送。又由于最多接收 2048 bytes，所以要 min(MSGLEN - bytes_recd, 2048)。

Python 的 len() 可以计算含有 \0 的消息的长度，而在 C 语言中不能使用 strlen 计算含有 \0 的消息的长度。

使用信息长度作为前缀

假设使用 5 个字符作为信息前缀来表示信息长度，那么你可能不能获取所有的 5 个字符在一个 recv 中，可能出现在网络负载高的情况下。所以你可以调用两次 recv -- 第一个决定长度，第二个获取剩余的信息。

二进制数据

可以使用 socket 发送二进制数据。主要的问题是并不是所有的机器都是用同样的二进制数据格式。比如摩托罗拉芯片使用两个十六进制 bytes 00 01 表示16进制整数 1。然而 Intel 和 DEC 是 byte-reversed -- 使用 01 00 表示 1。

在现在的 32 位机器上，用 ascii 表现的二进制数据通常比二进制表示的数据更小。因为在很多时候，数据中含有 0 或 1.字符串 “0” 是 2 bytes 而二进制是 4。所以，不适合用固定长度的信息。所以需要你选择合适的传递信息的策略当你想要能够使用 socket 传递字符串和二进制数据。

Python Struct 操纵二进制数据

>>> from struct import *
>>> pack('hhl', 1, 2, 3)
b'\x00\x01\x00\x02\x00\x00\x00\x03'
>>> unpack('hhl', b'\x00\x01\x00\x02\x00\x00\x00\x03')
(1, 2, 3)
>>> calcsize('hhl')
8

以上参考 https://docs.python.org/3/library/struct.html

断开连接

严格的说，在 close socket 之前，你应该调用 shutdown。根据传递给 shutdown 的参数，可以表示 “我不会再从这个 socket 读或向这个 socket 写数据”。大部分 socket 库，由于程序员老是忘记调用 shutdown，所以 close 相当于 shutdown(); close()。所以在大部分情况下，不需要显示调用 shutdown。

类似 HTTP 传输是可以有效地使用 shutdown。客户端在发送请求后调用 shutdown(1)。这告诉服务器 “这个客户端发送完了，但仍然会接收信息”。服务器可以通过收到 0 bytes 来知道这是 EOF（文档的结束）。

在 Python 中，如果 socket 被垃圾回收了，它会在需要时自动执行 close()。但依靠这个是非常糟糕的习惯。如果你的 socket 在消失前没有执行 close，那么另一边的 socket 会一直挂起。

什么时候该清除 Sockets

使用阻塞 sockets 时最糟糕的事可能是另一边挂了（而没有调用 close）。你的 socket 会一直挂起。TCP 是一个可靠的协议，所以在关闭连接之前，它会等待很久。如果你使用了线程，那么整个线程就挂了。对此你不能做什么。只要你不做一些愚蠢的事情，比如在做阻塞操作时加锁了，线程不会消耗很多资源。不要尝试取杀死这个线程 -- 线程比进程更高效的部分原因就是线程避免了自动资源回收。换句话说，如果你杀死了这个线程，那么你的整个进程很可能会挂掉。

非阻塞 Sockets

在 Python 中，你使用 socket.setblocking(0) 令 socket 非阻塞。在 C 语言中会更加复杂，但思想是相同的。你要在创建 socket 之后做这个。

机制的主要区别是 send、recv、connect、accpet 没有做任何事就会返回。你有很多选择。比如检查返回码和错误码，但这会使你的应用变大、容易出 bug 并且消耗大量 CPU。

使用 select。

在 C 语言中，使用 select 很复杂。在 Python 中，它十分容易，但它也足够接近 C 中的概念，如果你理解了 Python 中的 select，那么你理解 C 中的不会有很大问题：

ready_to_read, ready_to_write, in_error = \
               select.select(
                  potential_readers,
                  potential_writers,
                  potential_errs,
                  timeout)

传递给 select 三个参数：

所有你想读的 sockets 列表
所有你想写的 sockets 列表
所有你想检查错误的 sockets 列表

你应该注意一个 socket 可以出现在多个列表中。调用 select 是阻塞的，但你可以给它一个超时时间。

返回 3 个列表。分别包含可读的、可写的和错误的 sockets。

如果一个 socket 在可读列表中，那么调用对其 recv 一定会返回一些东西。对可写的也是同理。然后你可以对其使用上文阻塞操作中用到的读写方法。

创建 server socket，将其设置为非阻塞
将 server socket 放入 potential_readers
以 potential_readers 为参数调用 select
检查 ready_to_read，如果是 server socket，对其调用 accept，获取 client socket，将 client socket 设置为非阻塞
将 client socket 添加到 potential_writers 和 potential_readers 中
以 potential_writers 和 potential_readers 作为参数调用 select
从 potential_readers 的 client socket 中读取信息，并储存到 msg[client socket] 中
从 potential_writers 中获取 client socket，并向其发送 msg[client socket] 如果 msg[client socket] 存在

以上参考 https://pymotw.com/2/select/ 。

可移植性警告：在 Unix 中，select 对 sockets 和 files 都有效。而在 Windows 中，select 只对 sockets 有效。并且在 C 中，很多 socket 的高级特性在 Windows 中都不同。因此推荐在 Windows 中使用 thread。