說明

本文 翻譯自 realpython 網(wǎng)站上的文章教程 Socket Programming in Python (Guide)，由于原文很長(zhǎng)获黔，所以整理成了 Gitbook 方便閱讀淹仑。你可以去 首頁 下載 PDF/Mobi/ePub 格式文件或者 在線閱讀

原作者

Nathan Jennings 是 Real Python 教程團(tuán)隊(duì)的一員涌矢，他在很早之前就使用 C 語言開始了自己的編程生涯版仔，但是最終發(fā)現(xiàn)了 Python锯岖，從 Web 應(yīng)用和網(wǎng)絡(luò)數(shù)據(jù)收集到網(wǎng)絡(luò)安全钝凶，他喜歡任何 Pythonic 的東西
—— realpython

譯者注

譯者 是一名前端工程師仪芒，平常會(huì)寫很多的 JavaScript。但是當(dāng)我使用 JavaScript 很長(zhǎng)一段時(shí)間后腿椎，會(huì)對(duì)一些 語言無關(guān) 的編程概念感興趣桌硫，比如：網(wǎng)絡(luò)/socket 編程、異步/并發(fā)啃炸、線/進(jìn)程通信等铆隘。然而恰好這些內(nèi)容在 JavasScript 領(lǐng)域很少見

因?yàn)橐恢睆氖?Web 開發(fā)，所以我認(rèn)為理解了網(wǎng)絡(luò)通信及其 socket 編程就理解了 Web 開發(fā)的某些本質(zhì)南用。過程中我發(fā)現(xiàn) Python 社區(qū)有很多我喜歡的內(nèi)容膀钠，并且很多都是高質(zhì)量的公開發(fā)布且開源的。

最近我發(fā)現(xiàn)了這篇文章裹虫，系統(tǒng)地從底層網(wǎng)絡(luò)通信講到了應(yīng)用層協(xié)議及其 C/S 架構(gòu)的應(yīng)用程序肿嘲，由淺入深。雖然代碼筑公、API 使用了 Python雳窟，但是底層原理相通。非常值得一讀匣屡，推薦給大家

另外封救，由于本人水平所限拇涤，翻譯的內(nèi)容難免出現(xiàn)偏差，如果你在閱讀的過程中發(fā)現(xiàn)問題誉结，請(qǐng)毫不猶豫的提醒我或者開新 PR鹅士。或者有什么不理解的地方也可以開 issue 討論惩坑，當(dāng)然 star 也是歡迎的

授權(quán)

本文（翻譯版）通過了 realpython 官方授權(quán)掉盅，原文版權(quán)歸其所有，任何轉(zhuǎn)載請(qǐng)聯(lián)系他們以舒。翻譯版遵循本站 許可證協(xié)議

開始

網(wǎng)絡(luò)中的 Socket 和 Socket API 是用來跨網(wǎng)絡(luò)的消息傳送的趾痘，它提供了 進(jìn)程間通信(IPC) 的一種形式。網(wǎng)絡(luò)可以是邏輯的稀轨、本地的電腦網(wǎng)絡(luò)扼脐，或者是可以物理連接到外網(wǎng)的網(wǎng)絡(luò)岸军，并且可以連接到其它網(wǎng)絡(luò)奋刽。英特網(wǎng)就是一個(gè)明顯的例子，就是那個(gè)你通過 ISP 連接到的網(wǎng)絡(luò)

本篇教程有三個(gè)不同的迭代階段艰赞，來展示如何使用 Python 構(gòu)建一個(gè) Socket 服務(wù)器和客戶端

1. 我們將以一個(gè)簡(jiǎn)單的 Socket 服務(wù)器和客戶端程序來開始本教程
2. 當(dāng)你看完 API 了解例子是怎么運(yùn)行起來以后佣谐，我們將會(huì)看到一個(gè)具有同時(shí)處理多個(gè)連接能力的例子的改進(jìn)版
3. 最后，我們將會(huì)開發(fā)出一個(gè)更加完善且具有完整的自定義頭信息和內(nèi)容的 Socket 應(yīng)用

教程結(jié)束后方妖，你將學(xué)會(huì)如何使用 Python 中的 socket 模塊 來寫一個(gè)自己的客戶端/服務(wù)器應(yīng)用狭魂。以及向你展示如何在你的應(yīng)用中使用自定義類在不同的端之間發(fā)送消息和數(shù)據(jù)

所有的例子程序都使用 Python 3.6 編寫，你可以在 Github 上找到 源代碼

網(wǎng)絡(luò)和 Socket 是個(gè)很大的話題党觅。網(wǎng)上已經(jīng)有了關(guān)于它們的字面解釋雌澄，如果你還不是很了解 Socket 和網(wǎng)絡(luò)。當(dāng)你你讀到那些解釋的時(shí)候會(huì)感到不知所措杯瞻，這是非常正常的镐牺。因?yàn)槲乙彩沁@樣過來的

盡管如此也不要?dú)怵H。 我已經(jīng)為你寫了這個(gè)教程魁莉。 就像學(xué)習(xí) Python 一樣睬涧，我們可以一次學(xué)習(xí)一點(diǎn)。用你的瀏覽器保存本頁面到書簽旗唁，以便你學(xué)習(xí)下一部分時(shí)能找到

讓我們開始吧畦浓！

背景

Socket 有一段很長(zhǎng)的歷史，最初是在 1971 年被用于 ARPANET检疫，隨后就成了 1983 年發(fā)布的 Berkeley Software Distribution (BSD) 操作系統(tǒng)的 API讶请，并且被命名為 Berkeleysocket

當(dāng)互聯(lián)網(wǎng)在 20 世紀(jì) 90 年代隨萬維網(wǎng)興起時(shí)，網(wǎng)絡(luò)編程也火了起來屎媳。Web 服務(wù)和瀏覽器并不是唯一使用新的連接網(wǎng)絡(luò)和 Socket 的應(yīng)用程序夺溢。各種類型不同規(guī)模的客戶端/服務(wù)器應(yīng)用都廣泛地使用著它們

時(shí)至今日抹蚀，盡管 Socket API 使用的底層協(xié)議已經(jīng)進(jìn)化了很多年，也出現(xiàn)了許多新的協(xié)議企垦，但是底層的 API 仍然保持不變

Socket 應(yīng)用最常見的類型就是 客戶端/服務(wù)器 應(yīng)用环壤，服務(wù)器用來等待客戶端的鏈接。我們教程中涉及到的就是這類應(yīng)用钞诡。更明確地說郑现，我們將看到用于 InternetSocket 的 Socket API，有時(shí)稱為 Berkeley 或 BSD Socket荧降。當(dāng)然也有 Unix domain sockets —— 一種用于 同一主機(jī) 進(jìn)程間的通信

Socket API 概覽

Python 的 socket 模塊提供了使用 Berkeley sockets API 的接口接箫。這將會(huì)在我們這個(gè)教程里使用和討論到

主要的用到的 Socket API 函數(shù)和方法有下面這些：

• socket()
• bind()
• listen()
• accept()
• connect()
• connect_ex()
• send()
• recv()
• close()

Python 提供了和 C 語言一致且方便的 API。我們將在下面一節(jié)中用到它們

作為標(biāo)準(zhǔn)庫的一部分朵诫，Python 也有一些類可以讓我們方便的調(diào)用這些底層 Socket 函數(shù)辛友。盡管這個(gè)教程中并沒有涉及這部分內(nèi)容，你也可以通過socketserver 模塊 中找到文檔剪返。當(dāng)然還有很多實(shí)現(xiàn)了高層網(wǎng)絡(luò)協(xié)議（比如：HTTP, SMTP）的的模塊废累，可以在下面的鏈接中查到 Internet Protocols and Support

TCP Sockets

就如你馬上要看到的，我們將使用 socket.socket() 創(chuàng)建一個(gè)類型為 socket.SOCK_STREAM 的 socket 對(duì)象脱盲，默認(rèn)將使用 Transmission Control Protocol(TCP) 協(xié)議邑滨，這基本上就是你想使用的默認(rèn)值

為什么應(yīng)該使用 TCP 協(xié)議？

• 可靠的：網(wǎng)絡(luò)傳輸中丟失的數(shù)據(jù)包會(huì)被檢測(cè)到并重新發(fā)送
• 有序傳送：數(shù)據(jù)按發(fā)送者寫入的順序被讀取

相反钱反，使用 socket.SOCK_DGRAM 創(chuàng)建的 用戶數(shù)據(jù)報(bào)協(xié)議(UDP) Socket 是 不可靠 的掖看，而且數(shù)據(jù)的讀取寫發(fā)送可以是 無序的

為什么這個(gè)很重要？網(wǎng)絡(luò)總是會(huì)盡最大的努力去傳輸完整數(shù)據(jù)（往往不盡人意）面哥。沒法保證你的數(shù)據(jù)一定被送到目的地或者一定能接收到別人發(fā)送給你的數(shù)據(jù)

網(wǎng)絡(luò)設(shè)備（比如：路由器哎壳、交換機(jī)）都有帶寬限制，或者系統(tǒng)本身的極限尚卫。它們也有 CPU归榕、內(nèi)存、總線和接口包緩沖區(qū)焕毫，就像我們的客戶端和服務(wù)器茸歧。TCP 消除了你對(duì)于丟包弟灼、亂序以及其它網(wǎng)絡(luò)通信中通常出現(xiàn)的問題的顧慮

下面的示意圖中辖试，我們將看到 Socket API 的調(diào)用順序和 TCP 的數(shù)據(jù)流：

TCP Socket 流

左邊表示服務(wù)器帅涂，右邊則是客戶端

左上方開始，注意服務(wù)器創(chuàng)建「監(jiān)聽」Socket 的 API 調(diào)用：

• socket()
• bind()
• listen()
• accept()

「監(jiān)聽」Socket 做的事情就像它的名字一樣疙咸。它會(huì)監(jiān)聽客戶端的連接县匠，當(dāng)一個(gè)客戶端連接進(jìn)來的時(shí)候，服務(wù)器將調(diào)用 accept() 來「接受」或者「完成」此連接

客戶端調(diào)用 connect() 方法來建立與服務(wù)器的鏈接，并開始三次握手乞旦。握手很重要是因?yàn)樗ＷC了網(wǎng)絡(luò)的通信的雙方可以到達(dá)贼穆，也就是說客戶端可以正常連接到服務(wù)器，反之亦然

上圖中間部分往返部分表示客戶端和服務(wù)器的數(shù)據(jù)交換過程兰粉，調(diào)用了 send() 和 recv()方法

下面部分故痊，客戶端和服務(wù)器調(diào)用 close() 方法來關(guān)閉各自的 socket

打印客戶端和服務(wù)端

你現(xiàn)在已經(jīng)了解了基本的 socket API 以及客戶端和服務(wù)器是如何通信的，讓我們來創(chuàng)建一個(gè)客戶端和服務(wù)器玖姑。我們將會(huì)以一個(gè)簡(jiǎn)單的實(shí)現(xiàn)開始愕秫。服務(wù)器將打印客戶端發(fā)送回來的內(nèi)容

打印程序服務(wù)端

下面就是服務(wù)器代碼，echo-server.py：

#!/usr/bin/env python3

import socket

HOST = '127.0.0.1'  # 標(biāo)準(zhǔn)的回環(huán)地址 (localhost)
PORT = 65432        # 監(jiān)聽的端口 (非系統(tǒng)級(jí)的端口: 大于 1023)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen()
    conn, addr = s.accept()
    with conn:
        print('Connected by', addr)
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data)

注意：上面的代碼你可能還沒法完全理解焰络，但是不用擔(dān)心戴甩。這幾行代碼做了很多事情，這
只是一個(gè)起點(diǎn)闪彼，幫你看見這個(gè)簡(jiǎn)單的服務(wù)器是如何運(yùn)行的
教程后面有引用部分甜孤，里面有很多額外的引用資源鏈接，這個(gè)教程中我將把鏈接放在那兒

讓我們一起來看一下 API 調(diào)用以及發(fā)生了什么

socket.socket() 創(chuàng)建了一個(gè) socket 對(duì)象畏腕，并且支持 context manager type缴川，你可以使用 with 語句，這樣你就不用再手動(dòng)調(diào)用 s.close() 來關(guān)閉 socket 了

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    pass  # Use the socket object without calling s.close().

調(diào)用 socket() 時(shí)傳入的 socket 地址族參數(shù) socket.AF_INET 表示因特網(wǎng) IPv4 地址族郊尝，SOCK_STREAM 表示使用 TCP 的 socket 類型二跋，協(xié)議將被用來在網(wǎng)絡(luò)中傳輸消息

bind() 用來關(guān)聯(lián) socket 到指定的網(wǎng)絡(luò)接口（IP 地址）和端口號(hào)：

HOST = '127.0.0.1'
PORT = 65432

# ...

s.bind((HOST, PORT))

bind() 方法的入?yún)⑷Q于 socket 的地址族战惊，在這個(gè)例子中我們使用了 socket.AF_INET (IPv4)流昏，它將返回兩個(gè)元素的元組：(host, port)

host 可以是主機(jī)名稱、IP 地址吞获、空字符串况凉，如果使用 IP 地址，host 就應(yīng)該是 IPv4 格式的字符串各拷，127.0.0.1 是標(biāo)準(zhǔn)的 IPv4 回環(huán)地址刁绒，只有主機(jī)上的進(jìn)程可以連接到服務(wù)器，如果你傳了空字符串烤黍，服務(wù)器將接受本機(jī)所有可用的 IPv4 地址

端口號(hào)應(yīng)該是 1-65535 之間的整數(shù)（0是保留的）知市，這個(gè)整數(shù)就是用來接受客戶端鏈接的 TCP 端口號(hào)，如果端口號(hào)小于 1024速蕊，有的操作系統(tǒng)會(huì)要求管理員權(quán)限

使用 bind() 傳參為主機(jī)名稱的時(shí)候需要注意：

如果你在 host 部分 主機(jī)名稱 作為 IPv4/v6 socket 的地址嫂丙，程序可能會(huì)產(chǎn)生非確
定性的行為，因?yàn)?Python 會(huì)使用 DNS 解析后的 第一個(gè) 地址规哲，根據(jù) DNS 解析的結(jié)
果或者 host 配置 socket 地址將會(huì)以不同方式解析為實(shí)際的 IPv4/v6 地址跟啤。如果想得
到確定的結(jié)果傳入的 host 參數(shù)建議使用數(shù)字格式的地址 引用

我稍后將在 使用主機(jī)名 部分討論這個(gè)問題，但是現(xiàn)在也值得一提。目前來說你只需要知道當(dāng)使用主機(jī)名時(shí)隅肥，你將會(huì)因?yàn)?DNS 解析的原因得到不同的結(jié)果

可能是任何地址竿奏。比如第一次運(yùn)行程序時(shí)是 10.1.2.3，第二次是 192.168.0.1腥放，第三次是 172.16.7.8 等等

繼續(xù)看上面的服務(wù)器代碼示例泛啸，listen() 方法調(diào)用使服務(wù)器可以接受連接請(qǐng)求，這使它成為一個(gè)「監(jiān)聽中」的 socket

s.listen()
conn, addr = s.accept()

listen() 方法有一個(gè) backlog 參數(shù)秃症。它指定在拒絕新的連接之前系統(tǒng)將允許使用的 未接受的連接 數(shù)量平痰。從 Python 3.5 開始，這是可選參數(shù)伍纫。如果不指定宗雇，Python 將取一個(gè)默認(rèn)值

如果你的服務(wù)器需要同時(shí)接收很多連接請(qǐng)求，增加 backlog 參數(shù)的值可以加大等待鏈接請(qǐng)求隊(duì)列的長(zhǎng)度莹规，最大長(zhǎng)度取決于操作系統(tǒng)赔蒲。比如在 Linux 下，參考 /proc/sys/net/core/somaxconn

accept() 方法阻塞并等待傳入連接良漱。當(dāng)一個(gè)客戶端連接時(shí)舞虱，它將返回一個(gè)新的 socket 對(duì)象，對(duì)象中有表示當(dāng)前連接的 conn 和一個(gè)由主機(jī)母市、端口號(hào)組成的 IPv4/v6 連接的元組矾兜，更多關(guān)于元組值的內(nèi)容可以查看 [socket 地址族](#socket 地址族) 一節(jié)中的詳情

這里必須要明白我們通過調(diào)用 accept() 方法擁有了一個(gè)新的 socket 對(duì)象。這非常重要患久，因?yàn)槟銓⒂眠@個(gè) socket 對(duì)象和客戶端進(jìn)行通信椅寺。和監(jiān)聽一個(gè) socket 不同的是后者只用來授受新的連接請(qǐng)求

conn, addr = s.accept()
with conn:
    print('Connected by', addr)
    while True:
        data = conn.recv(1024)
        if not data:
            break
        conn.sendall(data)

從 accept() 獲取客戶端 socket 連接對(duì)象 conn 后，使用一個(gè)無限 while 循環(huán)來阻塞調(diào)用 conn.recv()蒋失，無論客戶端傳過來什么數(shù)據(jù)都會(huì)使用 conn.sendall() 打印出來

如果 conn.recv() 方法返回一個(gè)空 byte 對(duì)象（b''）返帕，然后客戶端關(guān)閉連接，循環(huán)結(jié)束篙挽，with 語句和 conn 一起使用時(shí)荆萤，通信結(jié)束的時(shí)候會(huì)自動(dòng)關(guān)閉 socket 鏈接

打印程序客戶端

現(xiàn)在我們來看下客戶端的程序，echo-client.py：

#!/usr/bin/env python3

import socket

HOST = '127.0.0.1'  # 服務(wù)器的主機(jī)名或者 IP 地址
PORT = 65432        # 服務(wù)器使用的端口

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    s.sendall(b'Hello, world')
    data = s.recv(1024)

print('Received', repr(data))

與服務(wù)器程序相比铣卡，客戶端程序簡(jiǎn)單很多链韭。它創(chuàng)建了一個(gè) socket 對(duì)象，連接到服務(wù)器并且調(diào)用 s.sendall() 方法發(fā)送消息煮落，然后再調(diào)用 s.recv() 方法讀取服務(wù)器返回的內(nèi)容并打印出來

運(yùn)行打印程序的客戶端和服務(wù)端

讓我們運(yùn)行打印程序的客戶端和服務(wù)端敞峭，觀察他們的表現(xiàn)，看看發(fā)生了什么事情

如果你在運(yùn)行示例代碼時(shí)遇到了問題州邢，可以閱讀 如何使用 Python 開發(fā)命令行命令儡陨，如果
你使用的是 windows 操作系統(tǒng)褪子，請(qǐng)查看 Python Windows FAQ

打開命令行程序，進(jìn)入你的代碼所在的目錄骗村，運(yùn)行打印程序的服務(wù)端：

$ ./echo-server.py

你的命令行將被掛起嫌褪，因?yàn)槌绦蛴幸粋€(gè)阻塞調(diào)用

conn, addr = s.accept()

它將等待客戶端的連接，現(xiàn)在再打開一個(gè)命令行窗口運(yùn)行打印程序的客戶端：

$ ./echo-client.py
Received b'Hello, world'

在服務(wù)端的窗口你將看見：

$ ./echo-server.py
Connected by ('127.0.0.1', 64623)

上面的輸出中胚股，服務(wù)端打印出了 s.accept() 返回的 addr 元組笼痛，這就是客戶端的 IP 地址和 TCP 端口號(hào)。示例中的端口號(hào)是 64623 這很可能是和你機(jī)器上運(yùn)行的結(jié)果不同

查看 socket 狀態(tài)

想查找你主機(jī)上 socket 的當(dāng)前狀態(tài)琅拌，可以使用 netstat 命令缨伊。這個(gè)命令在 macOS, Window, Linux 系統(tǒng)上默認(rèn)可用

下面這個(gè)就是啟動(dòng)服務(wù)后 netstat 命令的輸出結(jié)果：

$ netstat -an
Active Internet connections (including servers)
Proto Recv-Q Send-Q  Local Address          Foreign Address        (state)
tcp4       0      0  127.0.0.1.65432        *.*                    LISTEN

注意本地地址是 127.0.0.1.65432，如果 echo-server.py 文件中 HOST 設(shè)置成空字符串 '' 的話进宝，netstat 命令將顯示如下：

$ netstat -an
Active Internet connections (including servers)
Proto Recv-Q Send-Q  Local Address          Foreign Address        (state)
tcp4       0      0  *.65432                *.*                    LISTEN

本地地址是 *.65432刻坊，這表示所有主機(jī)支持的 IP 地址族都可以接受傳入連接，在我們的例子里面調(diào)用 socket() 時(shí)傳入的參數(shù) socket.AF_INET 表示使用了 IPv4 的 TCP socket党晋，你可以在輸出結(jié)果中的 Proto 列中看到(tcp4)

上面的輸出是我截取的只顯示了咱們的打印程序服務(wù)端進(jìn)程谭胚，你可能會(huì)看到更多輸出，具體取決于你運(yùn)行的系統(tǒng)未玻。需要注意的是 Proto, Local Address 和 state 列灾而。分別表示 TCP socket 類型、本地地址端口扳剿、當(dāng)前狀態(tài)

另外一個(gè)查看這些信息的方法是使用 lsof 命令旁趟，這個(gè)命令在 macOS 上是默認(rèn)安裝的，Linux 上需要你手動(dòng)安裝

$ lsof -i -n
COMMAND     PID   USER   FD   TYPE   DEVICE SIZE/OFF NODE NAME
Python    67982 nathan    3u  IPv4 0xecf272      0t0  TCP *:65432 (LISTEN)

isof 命令使用 -i 參數(shù)可以查看打開的 socket 連接的 COMMAND, PID(process id) 和 USER(user id)庇绽，上面的輸出就是打印程序服務(wù)端

netstat 和 isof 命令有許多可用的參數(shù)锡搜，這取決于你使用的操作系統(tǒng)×踩埃可以使用 man page 來查看他們的使用文檔余爆，這些文檔絕對(duì)值得花一點(diǎn)時(shí)間去了解，你將受益匪淺夸盟，macOS 和 Linux 中使用命令 man netstat 或者 man lsof 命令，windows 下使用 netstat /? 來查看幫助文檔

一個(gè)通常會(huì)犯的錯(cuò)誤是在沒有監(jiān)聽 socket 端口的情況下嘗試連接：

$ ./echo-client.py
Traceback (most recent call last):
  File "./echo-client.py", line 9, in <module>
    s.connect((HOST, PORT))
ConnectionRefusedError: [Errno 61] Connection refused

也可能是端口號(hào)出錯(cuò)像捶、服務(wù)端沒啟動(dòng)或者有防火墻阻止了連接上陕，這些原因可能很難記住，或許你也會(huì)碰到 Connection timed out 的錯(cuò)誤拓春，記得給你的防火墻添加允許我們使用的端口規(guī)則

引用部分有一些常見的 錯(cuò)誤

通信的流程分解

讓我們?cè)僮屑?xì)的觀察下客戶端是如何與服務(wù)端進(jìn)行通信的：

host

當(dāng)使用回環(huán)地址時(shí)释簿，數(shù)據(jù)將不會(huì)接觸到外部網(wǎng)絡(luò)，上圖中硼莽，回環(huán)地址包含在了 host 里面庶溶。這就是回環(huán)地址的本質(zhì)，連接數(shù)據(jù)傳輸是從本地到主機(jī)，這就是為什么你會(huì)聽到有回環(huán)地址或者 127.0.0.1偏螺、::1 的 IP 地址和表示本地主機(jī)

應(yīng)用程序使用回環(huán)地址來與主機(jī)上的其它進(jìn)程通信行疏，這使得它與外部網(wǎng)絡(luò)安全隔離。由于它是內(nèi)部的套像，只能從主機(jī)內(nèi)訪問酿联，所以它不會(huì)被暴露出去

如果你的應(yīng)用程序服務(wù)器使用自己的專用數(shù)據(jù)庫（非公用的），則可以配置服務(wù)器僅監(jiān)聽回環(huán)地址夺巩，這樣的話網(wǎng)絡(luò)上的其它主機(jī)就無法連接到你的數(shù)據(jù)庫

如果你的應(yīng)用程序中使用的 IP 地址不是 127.0.0.1 或者 ::1贞让，那就可能會(huì)綁定到連接到外部網(wǎng)絡(luò)的以太網(wǎng)上。這就是你通往 localhost 王國(guó)之外的其他主機(jī)的大門

external network

這里需要小心柳譬，并且可能讓你感到難受甚至懷疑全世界喳张。在你探索 localhost 的安全限制之前，確認(rèn)讀過 使用主機(jī)名 一節(jié)美澳。 一個(gè)安全注意事項(xiàng)是 不要使用主機(jī)名蹲姐，要使用
IP 地址

處理多個(gè)連接

打印程序的服務(wù)端肯定有它自己的一些局限。這個(gè)程序只能服務(wù)于一個(gè)客戶端然后結(jié)束人柿。打印程序的客戶端也有它自己的局限柴墩，但是還有一個(gè)問題，如果客戶端調(diào)用了下面的方法s.recv() 方法將返回 b'Hello, world' 中的一個(gè)字節(jié) b'H'

data = s.recv(1024)

1024 是緩沖區(qū)數(shù)據(jù)大小限制最大值參數(shù) bufsize凫岖，并不是說 recv() 方法只返回 1024個(gè)字節(jié)的內(nèi)容

send() 方法也是這個(gè)原理江咳，它返回發(fā)送內(nèi)容的字節(jié)數(shù)，結(jié)果可能小于傳入的發(fā)送內(nèi)容哥放，你得處理這處情況歼指，按需多次調(diào)用 send() 方法來發(fā)送完整的數(shù)據(jù)

應(yīng)用程序負(fù)責(zé)檢查是否已發(fā)送所有數(shù)據(jù)；如果僅傳輸了一些數(shù)據(jù)甥雕，則應(yīng)用程序需要嘗試傳
遞剩余數(shù)據(jù) 引用

我們可以使用 sendall() 方法來回避這個(gè)過程

和 send() 方法不一樣的是踩身，sendall() 方法會(huì)一直發(fā)送字節(jié)，只到所有的數(shù)據(jù)傳輸完成
或者中途出現(xiàn)錯(cuò)誤社露。成功的話會(huì)返回 None 引用

到目前為止挟阻，我們有兩個(gè)問題：

• 如何同時(shí)處理多個(gè)連接請(qǐng)求
• 我們需要一直調(diào)用 send() 或者 recv() 直到所有數(shù)據(jù)傳輸完成

應(yīng)該怎么做呢，有很多方式可以實(shí)現(xiàn)并發(fā)峭弟。最近附鸽，有一個(gè)非常流程的庫叫做 Asynchronous I/O 可以實(shí)現(xiàn)，asyncio 庫在 Python 3.4 后默認(rèn)添加到了標(biāo)準(zhǔn)庫里面瞒瘸。傳統(tǒng)的方法是使用線程

并發(fā)的問題是很難做到正確坷备，有許多細(xì)微之處需要考慮和防范∏槌簦可能其中一個(gè)細(xì)節(jié)的問題都會(huì)導(dǎo)致整個(gè)程序崩潰

我說這些并不是想嚇跑你或者讓你遠(yuǎn)離學(xué)習(xí)和使用并發(fā)編程省撑。如果你想讓程序支持大規(guī)模使用赌蔑，使用多處理器、多核是很有必要的竟秫。然而在這個(gè)教程中我們將使用比線程更傳統(tǒng)的方法使得邏輯更容易推理娃惯。我們將使用一個(gè)非常古老的系統(tǒng)調(diào)用：select()

select() 允許你檢查多個(gè) socket 的 I/O 完成情況，所以你可以使用它來檢測(cè)哪個(gè) socket I/O 是就緒狀態(tài)從而執(zhí)行讀取或?qū)懭氩僮骱枰。沁@是 Python石景，總會(huì)有更多其它的選擇，我們將使用標(biāo)準(zhǔn)庫中的selectors 模塊拙吉，所以我們使用了最有效的實(shí)現(xiàn)潮孽，不用在意你使用的操作系統(tǒng)：

這個(gè)模塊提供了高層且高效的 I/O 多路復(fù)用，基于原始的 select 模塊構(gòu)建，推薦用
戶使用這個(gè)模塊，除非他們需要精確到操作系統(tǒng)層面的使用控制 引用

盡管如此骄噪，使用 select() 也無法并發(fā)執(zhí)行。這取決于您的工作負(fù)載椎例，這種實(shí)現(xiàn)仍然會(huì)很快。這也取決于你的應(yīng)用程序?qū)B接所做的具體事情或者它需要支持的客戶端數(shù)量

asyncio 使用單線程來處理多任務(wù)请祖，使用事件循環(huán)來管理任務(wù)订歪。通過使用 select()，我們可以創(chuàng)建自己的事件循環(huán)肆捕，更簡(jiǎn)單且同步化刷晋。當(dāng)使用多線程時(shí)，即使要處理并發(fā)的情況慎陵，我們也不得不面臨使用 CPython 或者 PyPy 中的「全局解析器鎖 GIL」眼虱，這有效地限制了我們可以并行完成的工作量

說這些是為了解析為什么使用 select() 可能是個(gè)更好的選擇，不要覺得你必須使用 asyncio席纽、線程或最新的異步庫捏悬。通常，在網(wǎng)絡(luò)應(yīng)用程序中润梯，你的應(yīng)用程序就是 I/O 綁定：它可以在本地網(wǎng)絡(luò)上过牙，網(wǎng)絡(luò)另一端的端，磁盤上等待

如果你從客戶端收到啟動(dòng) CPU 綁定工作的請(qǐng)求仆救，查看 concurrent.futures模塊抒和，它包含一個(gè) ProcessPoolExecutor 類，用來異步執(zhí)行進(jìn)程池中的調(diào)用

如果你使用多進(jìn)程彤蔽，你的 Python 代碼將被操作系統(tǒng)并行地在不同處理器或者核心上調(diào)度運(yùn)行，并且沒有全局解析器鎖庙洼。你可以通過
Python 大會(huì)上的演講 John Reese - Thinking Outside the GIL with AsyncIO and Multiprocessing - PyCon 2018 來了解更多的想法

在下一節(jié)中顿痪，我們將介紹解決這些問題的服務(wù)器和客戶端的示例镊辕。他們使用 select() 來同時(shí)處理多連接請(qǐng)求，按需多次調(diào)用 send() 和 recv()

多連接的客戶端和服務(wù)端

下面兩節(jié)中蚁袭，我們將使用 selectors 模塊中的 selector 對(duì)象來創(chuàng)建一個(gè)可以同時(shí)處理多個(gè)請(qǐng)求的客戶端和服務(wù)端

多連接的服務(wù)端

首頁征懈，我們來看眼多連接服務(wù)端程序的代碼，multiconn-server.py揩悄。這是開始建立監(jiān)聽 socket 部分

import selectors
sel = selectors.DefaultSelector()
# ...
lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
lsock.bind((host, port))
lsock.listen()
print('listening on', (host, port))
lsock.setblocking(False)
sel.register(lsock, selectors.EVENT_READ, data=None)

這個(gè)程序和之前打印程序服務(wù)端最大的不同是使用了 lsock.setblocking(False) 配置 socket 為非阻塞模式卖哎，這個(gè) socket 的調(diào)用將不在是阻塞的。當(dāng)它和 sel.select() 一起使用的時(shí)候（下面會(huì)提到）删性，我們就可以等待 socket 就緒事件亏娜，然后執(zhí)行讀寫操作

sel.register() 使用 sel.select() 為你感興趣的事件注冊(cè) socket 監(jiān)控，對(duì)于監(jiān)聽 socket蹬挺，我們希望使用 selectors.EVENT_READ 讀取到事件

data 用來存儲(chǔ)任何你 socket 中想存的數(shù)據(jù)维贺，當(dāng) select() 返回的時(shí)候它也會(huì)返回。我們將使用 data 來跟蹤 socket 上發(fā)送或者接收的東西

下面就是事件循環(huán)：

import selectors
sel = selectors.DefaultSelector()

# ...

while True:
    events = sel.select(timeout=None)
    for key, mask in events:
        if key.data is None:
            accept_wrapper(key.fileobj)
        else:
            service_connection(key, mask)

sel.select(timeout=None) 調(diào)用會(huì)阻塞直到 socket I/O 就緒巴帮。它返回一個(gè)(key, events) 元組溯泣，每個(gè) socket 一個(gè)。key 就是一個(gè)包含 fileobj 屬性的具名元組榕茧。key.fileobj 是一個(gè) socket 對(duì)象垃沦，mask 表示一個(gè)操作就緒的事件掩碼

如果 key.data 為空，我們就可以知道它來自于監(jiān)聽 socket用押，我們需要調(diào)用 accept() 方法來授受連接請(qǐng)求肢簿。我們將使用一個(gè) accept() 包裝函數(shù)來獲取新的 socket 對(duì)象并注冊(cè)到 selector 上，我們馬上就會(huì)看到

如果 key.data 不為空只恨，我們就可以知道它是一個(gè)被接受的客戶端 socket译仗，我們需要為它服務(wù)，接著 service_connection() 會(huì)傳入 key 和 mask 參數(shù)并調(diào)用官觅，這包含了所有我們需要在 socket 上操作的東西

讓我們一起來看看 accept_wrapper() 方法做了什么：

def accept_wrapper(sock):
    conn, addr = sock.accept()  # Should be ready to read
    print('accepted connection from', addr)
    conn.setblocking(False)
    data = types.SimpleNamespace(addr=addr, inb=b'', outb=b'')
    events = selectors.EVENT_READ | selectors.EVENT_WRITE
    sel.register(conn, events, data=data)

由于監(jiān)聽 socket 被注冊(cè)到了 selectors.EVENT_READ 上纵菌，它現(xiàn)在就能被讀取，我們調(diào)用 sock.accept() 后立即再立即調(diào) conn.setblocking(False) 來讓 socket 進(jìn)入非阻塞模式

請(qǐng)記住休涤，這是這個(gè)版本服務(wù)器程序的主要目標(biāo)咱圆，因?yàn)槲覀儾幌Ｍ蛔枞Ｈ绻蛔枞Π保敲凑麄€(gè)服務(wù)器在返回前都處于掛起狀態(tài)序苏。這意味著其它 socket 處于等待狀態(tài)，這是一種 非常嚴(yán)重的 誰都不想見到的服務(wù)被掛起的狀態(tài)

接著我們使用了 types.SimpleNamespace 類創(chuàng)建了一個(gè)對(duì)象用來保存我們想要的 socket 和數(shù)據(jù)捷凄，由于我們得知道客戶端連接什么時(shí)候可以寫入或者讀取忱详，下面兩個(gè)事件都會(huì)被用到：

events = selectors.EVENT_READ | selectors.EVENT_WRITE

事件掩碼、socket 和數(shù)據(jù)對(duì)象都會(huì)被傳入 sel.register()

現(xiàn)在讓我們來看下跺涤，當(dāng)客戶端 socket 就緒的時(shí)候連接請(qǐng)求是如何使用 service_connection() 來處理的

def service_connection(key, mask):
    sock = key.fileobj
    data = key.data
    if mask & selectors.EVENT_READ:
        recv_data = sock.recv(1024)  # Should be ready to read
        if recv_data:
            data.outb += recv_data
        else:
            print('closing connection to', data.addr)
            sel.unregister(sock)
            sock.close()
    if mask & selectors.EVENT_WRITE:
        if data.outb:
            print('echoing', repr(data.outb), 'to', data.addr)
            sent = sock.send(data.outb)  # Should be ready to write
            data.outb = data.outb[sent:]

這就是多連接服務(wù)端的核心部分匈睁，key 就是從調(diào)用 select() 方法返回的一個(gè)具名元組监透，它包含了 socket 對(duì)象「fileobj」和數(shù)據(jù)對(duì)象。mask 包含了就緒的事件

如果 socket 就緒而且可以被讀取航唆，mask & selectors.EVENT_READ 就為真胀蛮，sock.recv() 會(huì)被調(diào)用。所有讀取到的數(shù)據(jù)都會(huì)被追加到 data.outb 里面糯钙。隨后被發(fā)送出去

注意 else: 語句粪狼，如果沒有收到任何數(shù)據(jù)：

if recv_data:
    data.outb += recv_data
else:
    print('closing connection to', data.addr)
    sel.unregister(sock)
    sock.close()

這表示客戶端關(guān)閉了它的 socket 連接，這時(shí)服務(wù)端也應(yīng)該關(guān)閉自己的連接任岸。不過別忘了先調(diào)用 sel.unregister() 來撤銷 select() 的監(jiān)控

當(dāng) socket 就緒而且可以被讀取的時(shí)候再榄，對(duì)于正常的 socket 應(yīng)該一直是這種狀態(tài)，任何接收并被 data.outb 存儲(chǔ)的數(shù)據(jù)都將使用 sock.send() 方法打印出來演闭。發(fā)送出去的字節(jié)隨后就會(huì)被從緩沖中刪除

data.outb = data.outb[sent:]

多連接的客戶端

現(xiàn)在讓我們一起來看看多連接的客戶端程序不跟，multiconn-client.py，它和服務(wù)端很相似米碰，不一樣的是它沒有監(jiān)聽連接請(qǐng)求窝革，它以調(diào)用 start_connections() 開始初始化連接：

messages = [b'Message 1 from client.', b'Message 2 from client.']


def start_connections(host, port, num_conns):
    server_addr = (host, port)
    for i in range(0, num_conns):
        connid = i + 1
        print('starting connection', connid, 'to', server_addr)
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.setblocking(False)
        sock.connect_ex(server_addr)
        events = selectors.EVENT_READ | selectors.EVENT_WRITE
        data = types.SimpleNamespace(connid=connid,
                                     msg_total=sum(len(m) for m in messages),
                                     recv_total=0,
                                     messages=list(messages),
                                     outb=b'')
        sel.register(sock, events, data=data)

num_conns 參數(shù)是從命令行讀取的，表示為服務(wù)器建立多少個(gè)鏈接吕座。就像服務(wù)端程序一樣虐译，每個(gè) socket 都設(shè)置成了非阻塞模式

由于 connect() 方法會(huì)立即觸發(fā)一個(gè) BlockingIOError 異常，所以我們使用 connect_ex() 方法取代它吴趴。connect_ex() 會(huì)返回一個(gè)錯(cuò)誤指示 errno.EINPROGRESS漆诽，不像 connect() 方法直接在進(jìn)程中返回異常。一旦連接結(jié)束锣枝，socket 就可以進(jìn)行讀寫并且通過 select() 方法返回

socket 建立完成后厢拭，我們將使用 types.SimpleNamespace 類創(chuàng)建想會(huì)傳送的數(shù)據(jù)。由于每個(gè)連接請(qǐng)求都會(huì)調(diào)用 socket.send()撇叁，發(fā)送到服務(wù)端的消息得使用 list(messages) 方法轉(zhuǎn)換成列表結(jié)構(gòu)供鸠。所有你想了解的東西，包括客戶端將要發(fā)送的陨闹、已發(fā)送的楞捂、已接收的消息以及消息的總字節(jié)數(shù)都存儲(chǔ)在 data 對(duì)象中

讓我們?cè)賮砜纯?service_connection()∏骼鳎基本上和服務(wù)端一樣：

def service_connection(key, mask):
    sock = key.fileobj
    data = key.data
    if mask & selectors.EVENT_READ:
        recv_data = sock.recv(1024)  # Should be ready to read
        if recv_data:
            print('received', repr(recv_data), 'from connection', data.connid)
            data.recv_total += len(recv_data)
        if not recv_data or data.recv_total == data.msg_total:
            print('closing connection', data.connid)
            sel.unregister(sock)
            sock.close()
    if mask & selectors.EVENT_WRITE:
        if not data.outb and data.messages:
            data.outb = data.messages.pop(0)
        if data.outb:
            print('sending', repr(data.outb), 'to connection', data.connid)
            sent = sock.send(data.outb)  # Should be ready to write
            data.outb = data.outb[sent:]

有一個(gè)不同的地方寨闹，客戶端會(huì)跟蹤從服務(wù)器接收的字節(jié)數(shù)，根據(jù)結(jié)果來決定是否關(guān)閉 socket 連接君账，服務(wù)端檢測(cè)到客戶端關(guān)閉則會(huì)同樣的關(guān)閉服務(wù)端的連接

運(yùn)行多連接的客戶端和服務(wù)端

現(xiàn)在讓我們把 multiconn-server.py 和 multiconn-client.py 兩個(gè)程序跑起來繁堡。他們都使用了命令行參數(shù)，如果不指定參數(shù)可以看到參數(shù)調(diào)用的方法：

服務(wù)端程序，傳入主機(jī)和端口號(hào)

$ ./multiconn-server.py
usage: ./multiconn-server.py <host> <port>

客戶端程序帖蔓，傳入啟動(dòng)服務(wù)端程序時(shí)同樣的主機(jī)和端口號(hào)以及連接數(shù)量

$ ./multiconn-client.py
usage: ./multiconn-client.py <host> <port> <num_connections>

下面就是服務(wù)端程序運(yùn)行起來在 65432 端口上監(jiān)聽回環(huán)地址的輸出：

$ ./multiconn-server.py 127.0.0.1 65432
listening on ('127.0.0.1', 65432)
accepted connection from ('127.0.0.1', 61354)
accepted connection from ('127.0.0.1', 61355)
echoing b'Message 1 from client.Message 2 from client.' to ('127.0.0.1', 61354)
echoing b'Message 1 from client.Message 2 from client.' to ('127.0.0.1', 61355)
closing connection to ('127.0.0.1', 61354)
closing connection to ('127.0.0.1', 61355)

下面是客戶端矮瘟，它創(chuàng)建了兩個(gè)連接請(qǐng)求到上面的服務(wù)端：

$ ./multiconn-client.py 127.0.0.1 65432 2
starting connection 1 to ('127.0.0.1', 65432)
starting connection 2 to ('127.0.0.1', 65432)
sending b'Message 1 from client.' to connection 1
sending b'Message 2 from client.' to connection 1
sending b'Message 1 from client.' to connection 2
sending b'Message 2 from client.' to connection 2
received b'Message 1 from client.Message 2 from client.' from connection 1
closing connection 1
received b'Message 1 from client.Message 2 from client.' from connection 2
closing connection 2

應(yīng)用程序客戶端和服務(wù)端

多連接的客戶端和服務(wù)端程序版本與最早的原始版本相比肯定有了很大的改善瞳脓，但是讓我們?cè)龠M(jìn)一步地解決上面「多連接」版本中的不足塑娇，然后完成最終版的實(shí)現(xiàn)：客戶端/服務(wù)器應(yīng)用程序

我們希望有個(gè)客戶端和服務(wù)端在不影響其它連接的情況下做好錯(cuò)誤處理，顯然劫侧，如果沒有發(fā)生異常埋酬，我們的客戶端和服務(wù)端不能崩潰的一團(tuán)糟。這也是到現(xiàn)在為止我們還沒討論的東西烧栋，我故意沒有引入錯(cuò)誤處理機(jī)制因?yàn)檫@樣可以使之前的程序容易理解

現(xiàn)在你對(duì)基本的 API写妥，非阻塞 socket、select() 等概念已經(jīng)有所了解了审姓。我們可以繼續(xù)添加一些錯(cuò)誤處理同時(shí)討論下「房間里面的大象」的問題珍特，我把一些東西隱藏在了幕后。你應(yīng)該還記得魔吐，我在介紹中討論到的自定義類

首先扎筒，讓我們先解決錯(cuò)誤：

所有的錯(cuò)誤都會(huì)觸發(fā)異常，像無效參數(shù)類型和內(nèi)存不足的常見異吵昴罚可以被拋出嗜桌；從 Python
3.3 開始，與 socket 或地址語義相關(guān)的錯(cuò)誤會(huì)引發(fā) OSError 或其子類之一的異常 引用

我們需要捕獲 OSError 異常辞色。另外一個(gè)我沒提及的的問題是延遲骨宠，你將在文檔的很多地方看見關(guān)于延遲的討論，延遲會(huì)發(fā)生而且屬于「正诚嗦」錯(cuò)誤层亿。主機(jī)或者路由器重啟、交換機(jī)端口出錯(cuò)立美、電纜出問題或者被拔出匿又，你應(yīng)該在你的代碼中處理好各種各樣的錯(cuò)誤

剛才說的「房間里面的大象」問題是怎么回事呢。就像 socket.SOCK_STREAM 這個(gè)參數(shù)的字面意思一樣悯辙，當(dāng)使用 TCP 連接時(shí)琳省，你會(huì)從一個(gè)連續(xù)的字節(jié)流讀取的數(shù)據(jù)，好比從磁盤上讀取數(shù)據(jù)躲撰，不同的是你是從網(wǎng)絡(luò)讀取字節(jié)流

然而针贬，和使用 f.seek() 讀文件不同，換句話說拢蛋，沒法定位 socket 的數(shù)據(jù)流的位置桦他，如果可以像文件一樣定位數(shù)據(jù)流的位置（使用下標(biāo)），那你就可以隨意的讀取你想要的數(shù)據(jù)

當(dāng)字節(jié)流入你的 socket 時(shí)，會(huì)需要有不同的網(wǎng)絡(luò)緩沖區(qū)快压，如果想讀取他們就必須先保存到其它地方圆仔，使用 recv() 方法持續(xù)的從 socket 上讀取可用的字節(jié)流

相當(dāng)于你從 socket 中讀取的是一塊一塊的數(shù)據(jù)，你必須使用 recv() 方法不斷的從緩沖區(qū)中讀取數(shù)據(jù)蔫劣，直到你的應(yīng)用確定讀取到了足夠的數(shù)據(jù)

什么時(shí)候算「足夠」這取決于你的定義坪郭，就 TCP socket 而言，它只通過網(wǎng)絡(luò)發(fā)送或接收原始字節(jié)脉幢。它并不了解這些原始字節(jié)的含義

這可以讓我們定義一個(gè)應(yīng)用層協(xié)議歪沃，什么是應(yīng)用層協(xié)議？簡(jiǎn)單來說嫌松，你的應(yīng)用會(huì)發(fā)送或者接收消息沪曙，這些消息其實(shí)就是你的應(yīng)用程序的協(xié)議

換句話說，這些消息的長(zhǎng)度萎羔、格式可以定義應(yīng)用程序的語義和行為液走，這和我們之前說的從socket 中讀取字節(jié)部分內(nèi)容相關(guān)，當(dāng)你使用 recv() 來讀取字節(jié)的時(shí)候贾陷，你需要知道讀的字節(jié)數(shù)缘眶，并且決定什么時(shí)候算讀取完成

這些都是怎么完成的呢？一個(gè)方法是只讀取固定長(zhǎng)度的消息昵宇，如果它們的長(zhǎng)度總是一樣的話磅崭，這樣做很容易。當(dāng)你收到固定長(zhǎng)度字節(jié)消息的時(shí)候瓦哎，就能確定它是個(gè)完整的消息

然而砸喻，如果你使用定長(zhǎng)模式來發(fā)送比較短的消息會(huì)比較低效，因?yàn)槟氵€得處理填充剩余的部分蒋譬，此外割岛，你還得處理數(shù)據(jù)不適合放在一個(gè)定長(zhǎng)消息里面的情況

在這個(gè)教程里面，我們將使用一個(gè)通用的方案犯助，很多協(xié)議都會(huì)用到它癣漆，包括 HTTP。我們將在每條消息前面追加一個(gè)頭信息剂买，頭信息中包括消息的長(zhǎng)度和其它我們需要的字段惠爽。這樣做的話我們只需要追蹤頭信息，當(dāng)我們讀到頭信息時(shí)瞬哼，就可以查到消息的長(zhǎng)度并且讀出所有字節(jié)然后消費(fèi)它

我們將通過使用一個(gè)自定義類來實(shí)現(xiàn)接收文本/二進(jìn)制數(shù)據(jù)婚肆。你可以在此基礎(chǔ)上做出改進(jìn)或者通過繼承這個(gè)類來擴(kuò)展你的應(yīng)用程序。重要的是你將看到一個(gè)例子實(shí)現(xiàn)它的過程

我將會(huì)提到一些關(guān)于 socket 和字節(jié)相關(guān)的東西坐慰，就像之前討論過的较性。當(dāng)你通過 socket 來發(fā)送或者接收數(shù)據(jù)時(shí)，其實(shí)你發(fā)送或者接收到的是原始字節(jié)

如果你收到數(shù)據(jù)并且想讓它在一個(gè)多字節(jié)解釋的上下文中使用，比如說 4-byte 的整形赞咙，你需要考慮它可能是一種不是你機(jī)器 CPU 本機(jī)的格式责循。客戶端或者服務(wù)器的另外一頭可能是另外一種使用了不同的字節(jié)序列的 CPU攀操，這樣的話院仿，你就得把它們轉(zhuǎn)換成你主機(jī)的本地字節(jié)序列來使用

上面所說的字節(jié)順序就是 CPU 的 字節(jié)序，在引用部分的字節(jié)序 一節(jié)可以查看更多崔赌。我們將會(huì)利用 Unicode 字符集的優(yōu)點(diǎn)來規(guī)避這個(gè)問題意蛀，并使用UTF-8 的方式編碼，由于 UTF-8 使用了 8字節(jié) 編碼方式沸手，所以就不會(huì)有字節(jié)序列的問題

你可以查看 Python 關(guān)于編碼與 Unicode 的 文檔虐秦，注意我們只會(huì)編碼消息的頭部。我們將使用嚴(yán)格的類型，發(fā)送的消息編碼格式會(huì)在頭信息中定義瘦癌。這將讓我們可以傳輸我們覺得有用的任意類型/格式數(shù)據(jù)

你可以通過調(diào)用 sys.byteorder 來決定你的機(jī)器的字節(jié)序列，比如在我的英特爾筆記本上澜掩，運(yùn)行下面的代碼就可以：

$ python3 -c 'import sys; print(repr(sys.byteorder))'
'little'

如果我把這段代碼跑在可以模擬大字節(jié)序 CPU「PowerPC」的虛擬機(jī)上的話贯涎，應(yīng)該是下面的結(jié)果：

$ python3 -c 'import sys; print(repr(sys.byteorder))'
'big'

在我們的例子程序中，應(yīng)用層的協(xié)議定義了使用 UTF-8 方式編碼的 Unicode 字符蠢沿。對(duì)于真正傳輸消息來說伸头，如果需要的話你還是得手動(dòng)交換字節(jié)序列

這取決于你的應(yīng)用，是否需要它來處理不同終端間的多字節(jié)二進(jìn)制數(shù)據(jù)舷蟀，你可以通過添加額外的頭信息來讓你的客戶端或者服務(wù)端支持二進(jìn)制恤磷，像 HTTP 一樣，把頭信息做為參數(shù)傳進(jìn)去

不用擔(dān)心自己還沒搞懂上面的東西野宜，下面一節(jié)我們看到是如果實(shí)現(xiàn)的

應(yīng)用的協(xié)議頭

讓我們來定義一個(gè)完整的協(xié)議頭：

• 可變長(zhǎng)度的文本
• 基于 UTF-8 編碼的 Unicode 字符集
• 使用 JSON 序列化的一個(gè) Python 字典

其中必須具有的頭應(yīng)該有以下幾個(gè)：

這些頭信息告訴接收者消息數(shù)據(jù)，這樣的話你就可以通過提供給接收者足夠的信息讓他接收到數(shù)據(jù)的時(shí)候正確的解碼的方式向它發(fā)送任何數(shù)據(jù)虎敦，由于頭信息是字典格式游岳，你可以隨意向頭信息中添加鍵值對(duì)

發(fā)送應(yīng)用程序消息

不過還有一個(gè)問題，由于我們使用了變長(zhǎng)的頭信息其徙，雖然方便擴(kuò)展但是當(dāng)你使用 recv() 方法讀取消息的時(shí)候怎么知道頭信息的長(zhǎng)度呢

我們前面講到過使用 recv() 接收數(shù)據(jù)和如何確定是否接收完成胚迫，我說過定長(zhǎng)的頭可能會(huì)很低效，的確如此擂橘。但是我們將使用一個(gè)比較小的 2 字節(jié)定長(zhǎng)的頭信息前綴來表示頭信息的長(zhǎng)度

你可以認(rèn)為這是一種混合的發(fā)送消息的實(shí)現(xiàn)方法晌区，我們通過發(fā)送頭信息長(zhǎng)度來引導(dǎo)接收者，方便他們解析消息體

為了給你更好地解釋消息格式，讓我們來看看消息的全貌：

message

消息以 2字節(jié)的固定長(zhǎng)度的頭開始朗若，這兩個(gè)字節(jié)是整型的網(wǎng)絡(luò)字節(jié)序列恼五，表示下面的變長(zhǎng) JSON 頭信息的長(zhǎng)度，當(dāng)我們從 recv() 方法讀取到 2 個(gè)字節(jié)時(shí)就知道它表示的是頭信息長(zhǎng)度的整形數(shù)字哭懈，然后在解碼 JSON 頭之前讀取這么多的字節(jié)

JSON 頭包含了頭信息的字典灾馒。其中一個(gè)就是 content-length，這表示消息內(nèi)容的數(shù)量（不是JSON頭）遣总，當(dāng)我們使用 recv() 方法讀取到了 content-length 個(gè)字節(jié)的數(shù)據(jù)時(shí)睬罗，就表示接收完成并且讀取到了完整的消息

應(yīng)用程序類

最后讓我們來看下成果，我們使用了一個(gè)消息類旭斥。來看看它是如何在 socket 發(fā)生讀寫事件時(shí)與 select() 配合使用的

對(duì)于這個(gè)示例應(yīng)用程序而言容达，我必須想出客戶端和服務(wù)器將使用什么類型的消息，從這一點(diǎn)來講這遠(yuǎn)遠(yuǎn)超過了最早時(shí)候我們寫的那個(gè)玩具一樣的打印程序

為了保證程序簡(jiǎn)單而且仍然能夠演示出它是如何在一個(gè)真正的程序中工作的垂券，我創(chuàng)建了一個(gè)應(yīng)用程序協(xié)議用來實(shí)現(xiàn)基本的搜索功能花盐。客戶端發(fā)送一個(gè)搜索請(qǐng)求菇爪，服務(wù)器做一次匹配的查找算芯，如果客戶端的請(qǐng)求沒法被識(shí)別成搜索請(qǐng)求，服務(wù)器就會(huì)假定這個(gè)是二進(jìn)制請(qǐng)求凳宙，對(duì)應(yīng)的返回二進(jìn)制響應(yīng)

跟著下面一節(jié)熙揍，運(yùn)行示例、用代碼做實(shí)驗(yàn)后你將會(huì)知道他是如何工作的氏涩，然后你就可以以這個(gè)消息類為起點(diǎn)把他修改成適合自己使用的

就像我們之前討論的届囚，你將在下面看到，處理 socket 時(shí)需要保存狀態(tài)削葱。通過使用類奖亚，我們可以將所有的狀態(tài)、數(shù)據(jù)和代碼打包到一個(gè)地方析砸。當(dāng)連接開始或者接受的時(shí)候消息類就會(huì)為每個(gè) socket 創(chuàng)建一個(gè)實(shí)例

類中的很多包裝方法昔字、工具方法在客戶端和服務(wù)端上都是差不多的。它們以下劃線開頭首繁，就像 Message._json_encode() 一樣作郭，這些方法通過類使用起來很簡(jiǎn)單。這使得它們?cè)谄渌椒ㄖ姓{(diào)用時(shí)更短弦疮，而且符合 DRY 原則

消息類的服務(wù)端程序本質(zhì)上和客戶端一樣夹攒。不同的是客戶端初始化連接并發(fā)送請(qǐng)求消息，隨后要處理服務(wù)端返回的內(nèi)容胁塞。而服務(wù)端則是等待連接請(qǐng)求咏尝，處理客戶端的請(qǐng)求消息压语，隨后發(fā)送響應(yīng)消息

看起來就像這樣：

下面是代碼的結(jié)構(gòu)：

消息入口點(diǎn)

我想通過首先提到它的設(shè)計(jì)方面來討論 Message 類的工作方式，不過這對(duì)我來說并不是立馬就能解釋清楚的编检，只有在重構(gòu)它至少五次之后我才能達(dá)到它目前的狀態(tài)胎食。為什么呢？因?yàn)橐芾頎顟B(tài)

當(dāng)消息對(duì)象創(chuàng)建的時(shí)候允懂，它就被一個(gè)使用 selector.register() 事件監(jiān)控起來的 socket 關(guān)聯(lián)起來了

message = libserver.Message(sel, conn, addr)
sel.register(conn, selectors.EVENT_READ, data=message)

注意厕怜，這一節(jié)中的一些代碼來自服務(wù)端主程序與消息類，但是這部分內(nèi)容的討論在客戶端
也是一樣的蕾总，我將在他們之間存在不同點(diǎn)的時(shí)候來解釋客戶端的版本

當(dāng) socket 上的事件就緒的時(shí)候粥航，它就會(huì)被 selector.select() 方法返回。對(duì)過 key 對(duì)象的 data 屬性獲取到 message 的引用生百，然后在消息用調(diào)用一個(gè)方法：

while True:
    events = sel.select(timeout=None)
    for key, mask in events:
        # ...
        message = key.data
        message.process_events(mask)

觀察上面的事件循環(huán)递雀，可以看見 sel.select() 位于「司機(jī)位置」，它是阻塞的置侍，在循環(huán)的上面等待映之。當(dāng) socket 上的讀寫事件就緒時(shí)，它就會(huì)為其服務(wù)蜡坊。這表示間接的它也要負(fù)責(zé)調(diào)用 process_events() 方法。這就是我說 process_events() 方法是入口的原因

讓我們來看下 process_events() 方法做了什么

def process_events(self, mask):
    if mask & selectors.EVENT_READ:
        self.read()
    if mask & selectors.EVENT_WRITE:
        self.write()

這樣做很好赎败，因?yàn)?process_events() 方法很簡(jiǎn)潔秕衙，它只可以做兩件事情：調(diào)用 read() 和 write() 方法

這又把我們帶回了狀態(tài)管理的問題。在幾次重構(gòu)后僵刮，我決定如果別的方法依賴于狀態(tài)變量里面的某個(gè)確定值据忘，那么它們就只應(yīng)該從 read() 和 write() 方法中調(diào)用，這將使處理socket 事件的邏輯盡量的簡(jiǎn)單

可能說起來很簡(jiǎn)單搞糕，但是經(jīng)歷了前面幾次類的迭代：混合了一些方法勇吊，檢查當(dāng)前狀態(tài)、依賴于其它值窍仰、在 read() 或者 write() 方法外面調(diào)用處理數(shù)據(jù)的方法汉规，最后這證明了這樣管理起來很復(fù)雜

當(dāng)然，你肯定需要把類按你自己的需求修改使它能夠符合你的預(yù)期驹吮，但是我建議你盡可能把狀態(tài)檢查针史、依賴狀態(tài)的調(diào)用的邏輯放在 read() 和 write() 方法里面

讓我們來看看 read() 方法，這是服務(wù)端版本碟狞，但是客戶端也是一樣的啄枕。不同之處在于方法名稱，一個(gè)（客戶端）是 process_response() 另一個(gè)（服務(wù)端）是 process_request()

def read(self):
    self._read()

    if self._jsonheader_len is None:
        self.process_protoheader()

    if self._jsonheader_len is not None:
        if self.jsonheader is None:
            self.process_jsonheader()

    if self.jsonheader:
        if self.request is None:
            self.process_request()

_read() 方法首頁被調(diào)用族沃，然后調(diào)用 socket.recv() 從 socket 讀取數(shù)據(jù)并存入到接收緩沖區(qū)

記住频祝，當(dāng)調(diào)用 socket.recv() 方法時(shí)泌参，組成消息的所有數(shù)據(jù)并沒有一次性全部到達(dá)。socket.recv() 方法可能需要調(diào)用很多次常空，這就是為什么在調(diào)用相關(guān)方法處理數(shù)據(jù)前每次都要檢查狀態(tài)

當(dāng)一個(gè)方法開始處理消息時(shí)沽一，首頁要檢查的就是接受緩沖區(qū)保存了足夠的多讀取的數(shù)據(jù)，如果確定窟绷，它們將繼續(xù)處理各自的數(shù)據(jù)锯玛，然后把數(shù)據(jù)存到其它流程可能會(huì)用到的變量上，并且清空自己的緩沖區(qū)兼蜈。由于一個(gè)消息有三個(gè)組件攘残，所以會(huì)有三個(gè)狀態(tài)檢查和處理方法的調(diào)用：

接下來，讓我們一起看看 write() 方法为狸，這是服務(wù)端的版本：

def write(self):
    if self.request:
        if not self.response_created:
            self.create_response()

    self._write()

write() 方法會(huì)首先檢測(cè)是否有請(qǐng)求歼郭，如果有而且響應(yīng)還沒被創(chuàng)建的話 create_response() 方法就會(huì)被調(diào)用，它會(huì)設(shè)置狀態(tài)變量 response_created辐棒，然后為發(fā)送緩沖區(qū)寫入響應(yīng)

如果發(fā)送緩沖區(qū)有數(shù)據(jù)病曾，write() 方法會(huì)調(diào)用 socket.send() 方法

記住，當(dāng) socket.send() 被調(diào)用時(shí)漾根，所有發(fā)送緩沖區(qū)的數(shù)據(jù)可能還沒進(jìn)入到發(fā)送隊(duì)列泰涂，socket 的網(wǎng)絡(luò)緩沖區(qū)可能滿了，socket.send() 可能需要重新調(diào)用辐怕，這就是為什么需要檢查狀態(tài)的原因逼蒙，create_response() 應(yīng)該只被調(diào)用一次，但是 _write() 方法需要調(diào)用多次

客戶端的 write() 版大體與服務(wù)端一致：

def write(self):
    if not self._request_queued:
        self.queue_request()

    self._write()

    if self._request_queued:
        if not self._send_buffer:
            # Set selector to listen for read events, we're done writing.
            self._set_selector_events_mask('r')

因?yàn)榭蛻舳耸醉摮跏蓟艘粋€(gè)連接請(qǐng)求到服務(wù)端寄疏，狀態(tài)變量_request_queued被檢查是牢。如果請(qǐng)求還沒加入到隊(duì)列，就調(diào)用 queue_request() 方法創(chuàng)建一個(gè)請(qǐng)求寫入到發(fā)送緩沖區(qū)中陕截，同時(shí)也會(huì)使用變量 _request_queued 記錄狀態(tài)值防止多次調(diào)用

就像服務(wù)端一樣驳棱，如果發(fā)送緩沖區(qū)有數(shù)據(jù) _write() 方法會(huì)調(diào)用 socket.send() 方法

需要注意客戶端版本的 write() 方法與服務(wù)端不同之處在于最后的請(qǐng)求是否加入到隊(duì)列中的檢查，這個(gè)我們將在客戶端主程序中詳細(xì)解釋农曲，原因是要告訴 selector.select()停止監(jiān)控 socket 的寫入事件而且我們只對(duì)讀取事件感興趣社搅，沒有辦法通知套接字是可寫的

我將在這一節(jié)中留下一個(gè)懸念，這一節(jié)的主要目的是解釋 selector.select() 方法是如何通過 process_events() 方法調(diào)用消息類以及它是如何工作的

這一點(diǎn)很重要朋蔫，因?yàn)?process_events() 方法在連接的生命周期中將被調(diào)用很多次罚渐，因此，要確保那些只能被調(diào)用一次的方法正常工作驯妄，這些方法中要么需要檢查自己的狀態(tài)變量荷并，要么需要檢查調(diào)用者的方法中的狀態(tài)變量

服務(wù)端主程序

在服務(wù)端主程序 app-server.py 中，主機(jī)青扔、端口參數(shù)是通過命令行傳遞給程序的：

$ ./app-server.py
usage: ./app-server.py <host> <port>

例如需求監(jiān)聽本地回環(huán)地址上面的 65432 端口源织，需要執(zhí)行：

$ ./app-server.py 127.0.0.1 65432
listening on ('127.0.0.1', 65432)

<host> 參數(shù)為空的話就可以監(jiān)聽主機(jī)上的所有 IP 地址

創(chuàng)建完 socket 后翩伪，一個(gè)傳入?yún)?shù) socket.SO_REUSEADDR 的方法 to socket.setsockopt() 將被調(diào)用

# Avoid bind() exception: OSError: [Errno 48] Address already in use
lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

設(shè)置這個(gè)參數(shù)是為了避免 端口被占用 的錯(cuò)誤發(fā)生，如果當(dāng)前程序使用的端口和之前的程序使用的一樣谈息，你就會(huì)發(fā)現(xiàn)連接處于 TIME_WAIT 狀態(tài)

比如說缘屹，如果服務(wù)器主動(dòng)關(guān)閉連接，服務(wù)器會(huì)保持為大概兩分鐘的 TIME_WAIT 狀態(tài)侠仇，具體時(shí)長(zhǎng)取決于你的操作系統(tǒng)轻姿。如果你想在兩分鐘內(nèi)再開啟一個(gè)服務(wù)，你將得到一個(gè)OSError 表示 端口被戰(zhàn)勝逻炊，這樣做是為了確保一些在途的數(shù)據(jù)包正確的被處理

事件循環(huán)會(huì)捕捉所有錯(cuò)誤互亮，以保證服務(wù)器正常運(yùn)行：

while True:
    events = sel.select(timeout=None)
    for key, mask in events:
        if key.data is None:
            accept_wrapper(key.fileobj)
        else:
            message = key.data
            try:
                message.process_events(mask)
            except Exception:
                print('main: error: exception for',
                      f'{message.addr}:\n{traceback.format_exc()}')
                message.close()

當(dāng)服務(wù)器接受到一個(gè)客戶端連接時(shí)，消息對(duì)象就會(huì)被創(chuàng)建：

def accept_wrapper(sock):
    conn, addr = sock.accept()  # Should be ready to read
    print('accepted connection from', addr)
    conn.setblocking(False)
    message = libserver.Message(sel, conn, addr)
    sel.register(conn, selectors.EVENT_READ, data=message)

消息對(duì)象會(huì)通過 sel.register() 方法關(guān)聯(lián)到 socket 上余素，而且它初始化就被設(shè)置成了只監(jiān)控讀事件豹休。當(dāng)請(qǐng)求被讀取時(shí)，我們將通過監(jiān)聽到的寫事件修改它

在服務(wù)器端采用這種方法的一個(gè)優(yōu)點(diǎn)是桨吊，大多數(shù)情況下威根，當(dāng) socket 正常并且沒有網(wǎng)絡(luò)問題時(shí)，它始終是可寫的

如果我們告訴 sel.register() 方法監(jiān)控 EVENT_WRITE 寫入事件视乐，事件循環(huán)將會(huì)立即喚醒并通知我們這種情況洛搀，然而此時(shí) socket 并不用喚醒調(diào)用 send() 方法。由于請(qǐng)求還沒被處理佑淀，所以不需要發(fā)回響應(yīng)姥卢。這將消耗并浪費(fèi)寶貴的 CPU 周期

服務(wù)端消息類

在消息切入點(diǎn)一節(jié)中，當(dāng)通過 process_events() 知道 socket 事件就緒時(shí)我們可以看到消息對(duì)象是如何發(fā)出動(dòng)作的≡郏現(xiàn)在讓我們來看看當(dāng)數(shù)據(jù)在 socket 上被讀取是會(huì)發(fā)生些什么，以及為服務(wù)器就緒的消息的組件片段發(fā)生了什么

libserver.py 文件中的服務(wù)端消息類僧叉，可以在 Github 上找到 源代碼

這些方法按照消息處理順序出現(xiàn)在類中

當(dāng)服務(wù)器讀取到至少兩個(gè)字節(jié)時(shí)奕枝，定長(zhǎng)頭的邏輯就可以開始了

def process_protoheader(self):
    hdrlen = 2
    if len(self._recv_buffer) >= hdrlen:
        self._jsonheader_len = struct.unpack('>H',
                                             self._recv_buffer[:hdrlen])[0]
        self._recv_buffer = self._recv_buffer[hdrlen:]

網(wǎng)絡(luò)字節(jié)序列中的定長(zhǎng)整型兩字節(jié)包含了 JSON 頭的長(zhǎng)度，struct.unpack() 方法用來讀取并解碼瓶堕，然后保存在 self._jsonheader_len 中隘道，當(dāng)這部分消息被處理完成后，就要調(diào)用 process_protoheader() 方法來刪除接收緩沖區(qū)中處理過的消息

就像上面的定長(zhǎng)頭的邏輯一樣郎笆，當(dāng)接收緩沖區(qū)有足夠的 JSON 頭數(shù)據(jù)時(shí)谭梗，它也需要被處理：

def process_jsonheader(self):
    hdrlen = self._jsonheader_len
    if len(self._recv_buffer) >= hdrlen:
        self.jsonheader = self._json_decode(self._recv_buffer[:hdrlen],
                                            'utf-8')
        self._recv_buffer = self._recv_buffer[hdrlen:]
        for reqhdr in ('byteorder', 'content-length', 'content-type',
                       'content-encoding'):
            if reqhdr not in self.jsonheader:
                raise ValueError(f'Missing required header "{reqhdr}".')

self._json_decode() 方法用來解碼并反序列化 JSON 頭成一個(gè)字典。由于我們定義的 JSON 頭是 utf-8 格式的宛蚓，所以解碼方法調(diào)用時(shí)我們寫死了這個(gè)參數(shù)激捏，結(jié)果將被存放在 self.jsonheader 中，process_jsonheader 方法做完他應(yīng)該做的事情后凄吏，同樣需要?jiǎng)h除接收緩沖區(qū)中處理過的消息

接下來就是真正的消息內(nèi)容远舅，當(dāng)接收緩沖區(qū)有 JSON 頭中定義的 content-length 值的數(shù)量個(gè)字節(jié)時(shí)闰蛔，請(qǐng)求就應(yīng)該被處理了：

def process_request(self):
    content_len = self.jsonheader['content-length']
    if not len(self._recv_buffer) >= content_len:
        return
    data = self._recv_buffer[:content_len]
    self._recv_buffer = self._recv_buffer[content_len:]
    if self.jsonheader['content-type'] == 'text/json':
        encoding = self.jsonheader['content-encoding']
        self.request = self._json_decode(data, encoding)
        print('received request', repr(self.request), 'from', self.addr)
    else:
        # Binary or unknown content-type
        self.request = data
        print(f'received {self.jsonheader["content-type"]} request from',
              self.addr)
    # Set selector to listen for write events, we're done reading.
    self._set_selector_events_mask('w')

把消息保存到 data 變量中后，process_request() 又會(huì)刪除接收緩沖區(qū)中處理過的數(shù)據(jù)图柏。接著序六，如果 content type 是 JSON 的話，它將解碼并反序列化數(shù)據(jù)蚤吹。否則（在我們的例子中）數(shù)據(jù)將被視 做二進(jìn)制數(shù)據(jù)并打印出來

最后 process_request() 方法會(huì)修改 selector 為只監(jiān)控寫入事件例诀。在服務(wù)端的程序 app-server.py 中，socket 初始化被設(shè)置成僅監(jiān)控讀事件〔米牛現(xiàn)在請(qǐng)求已經(jīng)被全部處理完了繁涂，我們對(duì)讀取事件就不感興趣了

現(xiàn)在就可以創(chuàng)建一個(gè)響應(yīng)寫入到 socket 中。當(dāng) socket 可寫時(shí) create_response() 將被從 write() 方法中調(diào)用：

def create_response(self):
    if self.jsonheader['content-type'] == 'text/json':
        response = self._create_response_json_content()
    else:
        # Binary or unknown content-type
        response = self._create_response_binary_content()
    message = self._create_message(**response)
    self.response_created = True
    self._send_buffer += message

響應(yīng)會(huì)根據(jù)不同的 content type 的不同而調(diào)用不同的方法創(chuàng)建跨算。在這個(gè)例子中爆土，當(dāng) action == 'search' 的時(shí)候會(huì)執(zhí)行一個(gè)簡(jiǎn)單的字典查找。你可以在這個(gè)地方添加你自己的處理方法并調(diào)用

一個(gè)不好處理的問題是響應(yīng)寫入完成時(shí)如何關(guān)閉連接诸蚕，我會(huì)在 _write() 方法中調(diào)用 close()

def _write(self):
    if self._send_buffer:
        print('sending', repr(self._send_buffer), 'to', self.addr)
        try:
            # Should be ready to write
            sent = self.sock.send(self._send_buffer)
        except BlockingIOError:
            # Resource temporarily unavailable (errno EWOULDBLOCK)
            pass
        else:
            self._send_buffer = self._send_buffer[sent:]
            # Close when the buffer is drained. The response has been sent.
            if sent and not self._send_buffer:
                self.close()

雖然close() 方法的調(diào)用有點(diǎn)隱蔽步势，但是我認(rèn)為這是一種權(quán)衡。因?yàn)橄㈩愐粋€(gè)連接只處理一條消息背犯。寫入響應(yīng)后坏瘩，服務(wù)器無需執(zhí)行任何操作。它的任務(wù)就完成了

客戶端主程序

客戶端主程序 app-client.py 中漠魏，參數(shù)從命令行中讀取倔矾，用來創(chuàng)建請(qǐng)求并連接到服務(wù)端

$ ./app-client.py
usage: ./app-client.py <host> <port> <action> <value>

來個(gè)示例演示一下：

$ ./app-client.py 127.0.0.1 65432 search needle

當(dāng)從命令行參數(shù)創(chuàng)建完一個(gè)字典來表示請(qǐng)求后，主機(jī)柱锹、端口哪自、請(qǐng)求字典一起被傳給 start_connection()

def start_connection(host, port, request):
    addr = (host, port)
    print('starting connection to', addr)
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.setblocking(False)
    sock.connect_ex(addr)
    events = selectors.EVENT_READ | selectors.EVENT_WRITE
    message = libclient.Message(sel, sock, addr, request)
    sel.register(sock, events, data=message)

對(duì)服務(wù)器的 socket 連接被創(chuàng)建，消息對(duì)象被傳入請(qǐng)求字典并創(chuàng)建

和服務(wù)端一樣禁熏，消息對(duì)象在 sel.register() 方法中被關(guān)聯(lián)到 socket 上壤巷。然而，客戶端不同的是瞧毙，socket 初始化的時(shí)候會(huì)監(jiān)控讀寫事件寡具，一旦請(qǐng)求被寫入淘正，我們將會(huì)修改為只監(jiān)控讀取事件

繼續(xù)閱讀