Python基礎（十）socket編程

時間 2019-11-13

標籤 python 基礎 socket 編程欄目 Python 简体版

原文原文鏈接

軟件架構

C/S架構

概念：html

　　C指client，客戶機、客戶端，供用戶使用python

　　S指server，服務器，處理軟件的邏輯linux

　　例如：QQ、WPS等軟件算法

特色：shell

　　軟戶須要安裝客戶端，經過客戶端訪問服務器編程

　　軟件更新時，服務器和客戶端都須要更新 json

　　C/S架構出的一個軟件不能夠跨平臺 windows

　　客戶端和服務器通訊採用自由協議，相對安全瀏覽器

B/S架構

概念：緩存

　　B指brower,瀏覽器，能夠看作特殊的客戶端（B/S能夠看做特殊的C/S）

　　例如：京東官網、知乎官網等

特色：

　　用戶經過瀏覽器訪問網頁的形式訪問服務器

　　只須要更新服務器

　　能夠跨平臺（只須要系統中有瀏覽器）

　　客戶端和服務器通訊採用通用的HTTP協議，相對不安全（https比http的網站更安全）

socket概念及分類

做用：socket（套接字）能夠實現客戶端與服務端的網絡通訊

OSI七層

若是向實現網絡基於網絡通訊的軟件就必須實現一系列網絡協議（網絡的核心就是一堆協議）

軟件屬於應用層

tcp是雙向鏈接的

socket抽象層

Socket是應用層與TCP/IP協議族通訊的中間軟件抽象層，它是一組接口。它把複雜的TCP/IP協議族隱藏在Socket接口後面，對用戶來講，一組簡單的接口就是所有，讓Socket去組織數據，以符合指定的協議。因此，咱們無需深刻理解tcp/udp協議，socket已經爲咱們封裝好了，咱們只須要遵循socket的規定去編程，寫出的程序天然就是遵循tcp/udp標準的。

也有人將socket說成 ip+port，ip是用來標識互聯網中的一臺主機的位置，而port是用來標識這臺機器上的一個應用程序，ip地址是配置到網卡上的，而port是應用程序開啓的，ip與port的綁定就標識了互聯網中獨一無二的一個應用程序

而程序的pid是同一臺機器上不一樣進程或者線程的標識

socket分類

套接字起源於 20 世紀 70 年代加利福尼亞大學伯克利分校版本的 Unix,即人們所說的 BSD Unix。所以,有時人們也把套接字稱爲「伯克利套接字」或「BSD 套接字」。一開始,套接字被設計用在同一臺主機上多個應用程序之間的通信。這也被稱進程間通信,或 IPC。

套接字有兩種（或者稱爲有兩個種族）,分別是基於文件型的和基於網絡型的。

基於文件類型的套接字家族

　　　套接字家族的名字：AF_UNIX

　　　unix一切皆文件，基於文件的套接字調用的就是底層的文件系統來取數據，兩個套接字進程運行在同一機器，能夠經過訪問同一個文件系統間接完成通訊

基於網絡類型的套接字家族

　　　套接字家族的名字：AF_INET

　　　(還有AF_INET6被用於ipv6，還有一些其餘的地址家族，不過AF_INET是使用最普遍的一個，python支持不少種地址家族，可是因爲咱們只關心網絡編程，因此大部分時候我麼只使用AF_INET)

socket工做流程

先從服務器端提及。服務器端先初始化Socket，而後與端口綁定(bind)，對端口進行監聽(listen)，調用accept阻塞，等待客戶端鏈接。在這時若是有個客戶端初始化一個Socket，而後鏈接服務器(connect)，若是鏈接成功，這時客戶端與服務器端的鏈接就創建了。客戶端發送數據請求，服務器端接收請求並處理請求，而後把迴應數據發送給客戶端，客戶端讀取數據，最後關閉鏈接，一次交互結束

基於tcp的套接字

服務端

ss = socket() #建立服務器套接字
ss.bind()      #把地址綁定到套接字
ss.listen()      #監聽連接
inf_loop:      #服務器無限循環
    cs = ss.accept() #接受客戶端連接
    comm_loop:         #通信循環
        cs.recv()/cs.send() #對話(接收與發送)
    cs.close()    #關閉客戶端套接字
ss.close()        #關閉服務器套接字(可選)

客戶端

cs = socket()    # 建立客戶套接字
 cs.connect()    # 嘗試鏈接服務器
 comm_loop:        # 通信循環
     cs.send()/cs.recv()    # 對話(發送/接收)
 cs.close()            # 關閉客戶套接字

tcp

三次握手時，是爲了創建客戶端和服務端之間的雙向鏈接，此時兩者之間沒有進行數據傳輸。

客戶端向服務端發送鏈接請求（訪問）；

服務端接收到並返回贊成（ACK），此時，從客戶端到服務器的單向鏈接打通，一塊兒返回的還有服務端對客戶端的鏈接請求；

客戶端收到請求並返回贊成（ACK），服務器到客戶端的單向鏈接打通。客戶端和服務端的雙向鏈接成功創建

四次揮手

客戶端數據發完了，向服務端發送斷開鏈接的請求；

服務端收到請求，返回贊成（ACK），此時客戶端到服務端的單向鏈接斷開；

服務端再向客戶端發送斷開鏈接的請求；

客戶端收到後，返回贊成，此時服務端到客戶端的單向鏈接也斷開。

爲何握手三次，揮手要四次？

第二次揮手後，服務端可能發送到客戶端的數據尚未傳輸結束，因此不能再第二次揮手時同時返回斷開鏈接的請求，就要加入第三次揮手。

一般四次揮手的FIN 1 通常都是由服務器發起的，服務器每次傳輸完數據後都會主動斷開鏈接，以節省資源，不會把時間浪費在TIME_WAIT上。這樣能夠提升服務器的對外訪問速度

例子

tcp是基於連接的，必須先啓動服務端，而後再啓動客戶端去連接服務端

 1 import socket
 2 
 3 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM )
 4 # socket.AF_INET  指地址家族
 5 # socket.SOCK_STREM 指面向鏈接，基於tcp協議
 6 
 7 phone.bind(('192.168.0.106', 8000))
 8 
 9 phone.listen(5) #容許創建的最大鏈接數
10 
11 connect, addr = phone.accept()
12 
13 recv_msg = connect.recv(1024)
14 print('從客戶端發來的信息是：', recv_msg)
15 
16 send_msg = '我已經收到你的消息了，是否是：'.encode('utf-8') + recv_msg
17 connect.send(send_msg)
18 
19 connect.close()
20 phone.close()

服務端

import socket

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

phone.connect(('192.168.0.106', 8000)) #鏈接到服務的的端口

phone.send('hello python!'.encode('utf-8'))

msg = phone.recv(1024)
print('收到的消息是：', msg.decode('utf-8'))

客戶端

添加鏈接循環、通訊循環和異常處理

 1 # 加入while循環，實現交互
 2 
 3 # import socket
 4 
 5 from socket import *
 6 
 7 ip_port = ('192.168.0.106', 7000)
 8 back_log = 5
 9 buffer_size = 1024
10 
11 tcp_server = socket(AF_INET, SOCK_STREAM)
12 tcp_server.bind(ip_port)
13 tcp_server.listen(back_log)
14 
15 while True: #添加鏈接循環
16     print('服務端開始運行====>')
17     connect, addr = tcp_server.accept()
18     print('雙向鏈接：', connect)
19     print('客戶端地址：', addr)
20     while True: #添加通訊循環
21         try:
22             rec_msg = connect.recv(buffer_size)
23             print('從客戶端收到的消息：', rec_msg.decode('utf-8'))
24             connect.send(rec_msg.upper())
25             print('客戶端信息發送成功')
26         except Exception:
27             break
28     connect.close()
29 
30 tcp_server.close()

服務端

 1 from socket import *
 2 
 3 ip_port = ('192.168.0.106', 7000)
 4 back_log = 5
 5 buffer_size = 1024
 6 
 7 tcp_client = socket(AF_INET, SOCK_STREAM)
 8 
 9 tcp_client.connect(ip_port)
10 
11 while True:
12     msg = input('請輸入-->')
13     if not msg:continue
14     tcp_client.send(msg.encode('utf-8'))
15     print('客戶端a發送成功')
16     rev_msg = tcp_client.recv(buffer_size)
17     print('從服務端收到的消息：', rev_msg.decode('utf-8'))
18 
19 tcp_client.close()

客戶端a

 1 from socket import *
 2 
 3 ip_port = ('192.168.0.106', 7000)
 4 back_log = 5
 5 buffer_size = 1024
 6 
 7 tcp_client = socket(AF_INET, SOCK_STREAM)
 8 
 9 tcp_client.connect(ip_port)
10 
11 while True:
12     msg = input('請輸入-->')
13     if not msg:continue
14     tcp_client.send(msg.encode('utf-8'))
15     print('客戶端b發送成功')
16     rev_msg = tcp_client.recv(buffer_size)
17     print('從服務端收到的消息：', rev_msg.decode('utf-8'))
18 
19 tcp_client.close()

客戶端b

注意：

　　這個例子中 tcp 話不能實現併發

　　rec send都要通過操做系統-網卡，從內核態內存中讀取數據到用戶態內存. 客戶端若是發送爲空（好比回車），此時服務端的緩衝區爲空，recv就會卡住，能夠加入if 解決

　　內核態內存存放操做系統的相關內存

　　用戶態內存存放其餘用戶程序的相關內存

Address already in use 這個是因爲你的服務端仍然存在四次揮手的time_wait狀態在佔用地址

解決方法：

#加入一條socket配置，重用ip和端口

phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind(('127.0.0.1',8080))

加入socket配置

發現系統存在大量TIME_WAIT狀態的鏈接，經過調整linux內核參數解決，
vi /etc/sysctl.conf

編輯文件，加入如下內容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
 
而後執行 /sbin/sysctl -p 讓參數生效。
 
net.ipv4.tcp_syncookies = 1 表示開啓SYN Cookies。當出現SYN等待隊列溢出時，啓用cookies來處理，可防範少許SYN攻擊，默認爲0，表示關閉；

net.ipv4.tcp_tw_reuse = 1 表示開啓重用。容許將TIME-WAIT sockets從新用於新的TCP鏈接，默認爲0，表示關閉；

net.ipv4.tcp_tw_recycle = 1 表示開啓TCP鏈接中TIME-WAIT sockets的快速回收，默認爲0，表示關閉。

net.ipv4.tcp_fin_timeout 修改系統默認的 TIMEOUT 時間

或者調整linux內核

基於udp的套接字

udp是無連接的，先啓動哪一端都不會報錯

服務端

1  ss = socket()   #建立一個服務器的套接字
2  ss.bind()       #綁定服務器套接字
3  inf_loop:       #服務器無限循環
4      cs = ss.recvfrom()/ss.sendto() # 對話(接收與發送)
5  ss.close()                         # 關閉服務器套接字

客戶端

cs = socket()   # 建立客戶套接字
comm_loop:      # 通信循環
    cs.sendto()/cs.recvfrom()   # 對話(發送/接收)
cs.close()                      # 關閉客戶套接字

簡單示例

 1 import time
 2 from socket import *
 3 
 4 ip_port = ('192.168.0.106', 7000)
 5 buffer_size = 1024
 6 
 7 udp_server = socket(AF_INET, SOCK_DGRAM)
 8 udp_server.bind(ip_port)
 9 
10 while True:
11     msg, addr = udp_server.recvfrom(buffer_size)
12 
13     if not msg:
14         fmt = '%Y-%m-%d %X'
15     else:
16         fmt = msg.decode('utf-8')
17     send_msg = time.strftime(fmt)
18 
19     udp_server.sendto(send_msg.encode('utf-8'), addr)

udp服務端

from socket import *

ip_port = ('192.168.0.106', 7000)
buffer_size = 1024

udp_client = socket(AF_INET, SOCK_DGRAM) #數據包 data gram

while True:
    msg = input('請輸入-->')
    udp_client.sendto(msg.encode('utf-8'), ip_port)

    re_msg, addr = udp_client.recvfrom(buffer_size)
    print(re_msg)

udp客戶端a

 1 from socket import *
 2 
 3 ip_port = ('192.168.0.106', 7000)
 4 buffer_size = 1024
 5 
 6 udp_client = socket(AF_INET, SOCK_DGRAM) #數據包 data gram
 7 
 8 while True:
 9     msg = input('請輸入-->')
10     udp_client.sendto(msg.encode('utf-8'), ip_port)
11 
12     re_msg, addr = udp_client.recvfrom(buffer_size)
13     print(re_msg)

udp客戶端b

因爲udp是無鏈接的，因此多個客戶端能夠同時跟服務端通訊

粘包

粘包現象

利用tcp製做一個遠程執行命令的程序

read出的結果是以當前所在的系統爲準的，若是是windows，那麼res.stdout.read()讀出的就是GBK編碼的，在接收端須要用GBK解碼

且只能從管道里讀一次結果

 1 from  socket import *
 2 import subprocess
 3 
 4 ip_port = ('192.168.0.106', 7070)
 5 back_log = 5
 6 buffer_size = 1024
 7 
 8 s_server = socket(AF_INET, SOCK_STREAM)
 9 s_server.bind(ip_port)
10 s_server.listen(back_log)
11 
12 while True:
13     con, addr = s_server.accept()
14     print('鏈接成功', addr)
15 
16     while True:
17         try:
18             cmd = con.recv(buffer_size)
19             if not cmd:break
20             # 執行命令並獲得命令的執行結果
21             res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
22                                    stderr=subprocess.PIPE,
23                                    stdout=subprocess.PIPE,
24                                    stdin=subprocess.PIPE)
25             err = res.stderr.read()
26             if err:
27                 cmd_res = err
28             else:
29                 cmd_res = res.stdout.read()
30 
31             if not cmd_res:
32                 cmd_res = '執行成功呀呀呀'.encode('GBK')
33             con.send(cmd_res)
34         except Exception as e:
35             print(e)
36             break
37             # con.close()
38 s_server.close()

服務端

from  socket import *

ip_port = ('192.168.0.106', 7070)
back_log = 5
buffer_size = 1024

s_client = socket(AF_INET, SOCK_STREAM)
s_client.connect(ip_port)

while True:
    cmd = input('請輸入-->')
    if not cmd:continue
    s_client.send(cmd.encode('utf-8'))

    cmd_res = s_client.recv(buffer_size)
    print('命令執行結果是：', cmd_res.decode('GBK'))

s_client.close()

客戶端

利用udp製做一個遠程執行命令的程序

from socket import *
import subprocess

ip_port = ('192.168.0.106', 6060)
buffer_size = 1024

udp_ser = socket(AF_INET, SOCK_DGRAM)
udp_ser.bind(ip_port)

while True:
    msg, addr = udp_ser.recvfrom(buffer_size)

    res = subprocess.Popen(msg.decode('utf-8'), shell=True,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE,
                     stdin=subprocess.PIPE)
    err = res.stderr.read()

    if err:
        msg_send = err
    else:
        msg_send = res.stdout.read()
    if not msg_send:
        msg_send = '執行成功呀呀呀'.encode('GBK')

    udp_ser.sendto(msg_send, addr)


udp_ser.close()

服務端

 1 from  socket import *
 2 
 3 ip_port = ('192.168.0.106', 6060)
 4 buffer_size = 1024
 5 
 6 udp_client = socket(AF_INET, SOCK_DGRAM)
 7 
 8 while True:
 9     msg_send = input('請輸入-->')
10     udp_client.sendto(msg_send.encode('utf-8'), ip_port)
11 
12     msg_rev, addr = udp_client.recvfrom(buffer_size)
13     print(msg_rev.decode('gbk'),end='')
14 
15 # udp_client.close()

客戶端

粘包分析

只有TCP有粘包現象，UDP永遠不會粘包

發送端能夠是一K一K地發送數據，而接收端的應用程序能夠兩K兩K地提走數據，固然也有可能一次提走3K或6K數據，或者一次只提走幾個字節的數據，也就是說，應用程序所看到的數據是一個總體，或說是一個流（stream），一條消息有多少字節對應用程序是不可見的，所以TCP協議是面向流的協議，這也是容易出現粘包問題的緣由。

而UDP是面向消息的協議，每一個UDP段都是一條消息，應用程序必須以消息爲單位提取數據，不能一次提取任意字節的數據，這一點和TCP是很不一樣的。怎樣定義消息呢？能夠認爲對方一次性write/send的數據爲一個消息，須要明白的是當對方send一條信息的時候，不管底層怎樣分段分片，TCP協議層會把構成整條消息的數據段排序完成後才呈如今內核緩衝區。

例如基於tcp的套接字客戶端往服務端上傳文件，發送時文件內容是按照一段一段的字節流發送的，在接收方看了，根本不知道該文件的字節流從何處開始，在何處結束

只有tcp會粘包，udp不會

所謂粘包問題主要是由於接收方不知道不一樣信息之間的界限，不知道該提取多少字節而形成的

TCP（transport control protocol，傳輸控制協議）是面向鏈接的，面向流的，提供高可靠性服務。收發兩端（客戶端和服務器端）都要有一一成對的socket，所以，發送端爲了將多個發往接收端的包，更有效的發到對方，使用了優化方法（Nagle算法），將屢次間隔較小且數據量小的數據，合併成一個大的數據塊，而後進行封包。這樣，接收端，就難於分辨出來了，必須提供科學的拆包機制。即面向流的通訊是無消息保護邊界的。

UDP（user datagram protocol，用戶數據報協議）是無鏈接的，面向消息的，提供高效率服務。不會使用塊的合併優化算法，, 因爲UDP支持的是一對多的模式，因此接收端的skbuff(套接字緩衝區）採用了鏈式結構來記錄每個到達的UDP包，在每一個UDP包中就有了消息頭（消息來源地址，端口等信息），這樣，對於接收端來講，就容易進行區分處理了。 即面向消息的通訊是有消息保護邊界的。

tcp是基於數據流的，因而收發的消息不能爲空，這就須要在客戶端和服務端都添加空消息的處理機制，防止程序卡住，而udp是基於數據報的，即使是你輸入的是空內容（直接回車），那也不是空消息，udp協議會幫你封裝上消息頭

tcp: send發消息 recv收消息

udp： sendto發消息 recvfrom收消息

一個recvfrom(x)必須對惟一一個sendinto(y),收完了x個字節的數據就算完成,如果y>x數據就丟失，這意味着udp根本不會粘包，可是會丟數據，不可靠

tcp的協議數據不會丟，沒有收完包，下次接收，會繼續上次繼續接收，己端老是在收到ack時纔會清除緩衝區內容。數據是可靠的，可是會粘包。

粘包的兩種狀況

發送端須要等緩衝區滿才發送出去，形成粘包（發送數據時間間隔很短，數據了很小，會合到一塊兒，產生粘包）

接收方不及時接收緩衝區的包，形成多個包接收（客戶端發送了一段數據，服務端只收了一小部分，服務端下次再收的時候仍是從緩衝區拿上次遺留的數據，產生粘包）

拆包的狀況

當發送端緩衝區的長度大於網卡的MTU時，tcp會將此次發送的數據拆成幾個數據包發送出去。

爲何tcp是可靠傳輸，udp是不可靠傳輸？

tcp在數據傳輸時，發送端先把數據發送到本身的緩存中，而後協議控制將緩存中的數據發往對端，對端返回一個ack=1，發送端則清理緩存中的數據，對端返回ack=0，則從新發送數據，因此tcp是可靠的；

而udp發送數據，對端是不會返回確認信息的，所以不可靠

send(字節流)和recv(1024)及sendall

recv裏指定的1024意思是從緩存裏一次拿出1024個字節的數據

send的字節流是先放入己端緩存，而後由協議控制將緩存內容發往對端，若是待發送的字節流大小大於緩存剩餘空間，那麼數據丟失，用sendall就會循環調用send，數據不會丟失

解決粘包

問題的根源在於，接收端不知道發送端將要傳送的字節流的長度，因此解決粘包的方法就是圍繞，如何讓發送端在發送數據前，把本身將要發送的字節流總大小讓接收端知曉，而後接收端來一個死循環接收完全部數據

low版本的解決方法

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket,subprocess
 4 ip_port=('127.0.0.1',8080)
 5 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 6 s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 7 
 8 s.bind(ip_port)
 9 s.listen(5)
10 
11 while True:
12     conn,addr=s.accept()
13     print('客戶端',addr)
14     while True:
15         msg=conn.recv(1024)
16         if not msg:break
17         res=subprocess.Popen(msg.decode('utf-8'),shell=True,\
18                             stdin=subprocess.PIPE,\
19                          stderr=subprocess.PIPE,\
20                          stdout=subprocess.PIPE)
21         err=res.stderr.read()
22         if err:
23             ret=err
24         else:
25             ret=res.stdout.read()
26         data_length=len(ret)
27         conn.send(str(data_length).encode('utf-8')) #告訴對面真正數據的長度
28         data=conn.recv(1024).decode('utf-8')
29         if data == 'recv_ready': #發送真正的數據
30             conn.sendall(ret)
31     conn.close()

服務端

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 import socket,time
 4 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 res=s.connect_ex(('127.0.0.1',8080))
 6 
 7 while True:
 8     msg=input('>>: ').strip()
 9     if len(msg) == 0:continue
10     if msg == 'quit':break
11 
12     s.send(msg.encode('utf-8'))
13     length=int(s.recv(1024).decode('utf-8')) #知道了該接收多少字節的數據
14     s.send('recv_ready'.encode('utf-8'))
15     send_size=0
16     recv_size=0
17     data=b''
18     while recv_size < length:
19         data+=s.recv(1024)
20         recv_size+=len(data)
21 
22 
23     print(data.decode('utf-8'))

客戶端

爲什麼low：

程序的運行速度遠快於網絡傳輸速度，因此在發送一段字節前，先用send去發送該字節流長度，這種方式會放大網絡延遲帶來的性能損耗

解決方法：

爲字節流加上自定義固定長度報頭，報頭中包含字節流長度，而後一次send到對端，對端在接收時，先從緩存中取出定長的報頭，而後再取真實數據。

import json,struct
#假設經過客戶端上傳1T:1073741824000的文件a.txt

#爲避免粘包,必須自定製報頭
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T數據,文件路徑和md5值

#爲了該報頭能傳送,須要序列化而且轉爲bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化並轉成bytes,用於傳輸

#爲了讓客戶端知道報頭的長度,用struck將報頭長度這個數字轉成固定長度:4個字節
head_len_bytes=struct.pack('i',len(head_bytes)) #這4個字節裏只包含了一個數字,該數字是報頭的長度

#客戶端開始發送
conn.send(head_len_bytes) #先發報頭的長度,4個bytes
conn.send(head_bytes) #再發報頭的字節格式
conn.sendall(文件內容) #而後發真實內容的字節格式

#服務端開始接收
head_len_bytes=s.recv(4) #先收報頭4個bytes,獲得報頭長度的字節格式
x=struct.unpack('i',head_len_bytes)[0] #提取報頭的長度

head_bytes=s.recv(x) #按照報頭長度x,收取報頭的bytes格式
header=json.loads(json.dumps(header)) #提取報頭

#最後根據報頭的內容提取真實的數據,好比
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)

sruct模塊

該模塊能夠把一個類型，如數字，轉成固定長度的bytes

>>> struct.pack('i',1111111111111)

。。。。。。。。。

struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #這個是範圍

recv和recvfrom

tcp: send發消息 recv收消息

udp： sendto發消息 recvfrom收消息

（1）tcp協議：

　　若是收消息時緩衝區中數據爲空，那麼recv會堵塞

　　tcp基於連接通訊，若是一端斷開了連接，那麼另外一端的連接也跟着結束，recv不會堵塞，會一直收空

（2）udp協議

　　若是消息緩衝區數據爲空，recvfrom不會堵塞

　　recvfrom收的數據小於sento發送的數據時，數據丟失

　　只有sendto沒有recvfrom，數據也會丟失

udp協議只把包發出去，無論對方收不收，而tcp是基於連接的，必須有一個服務端在運行着，客戶端去和服務端創建雙向連接才能傳遞信息，任何一方摧毀連接都會致使對方程序崩潰。

總結：

一個recvfrom(x)必須對惟一一個sendinto(y),收完了x個字節的數據就算完成,如果y>x數據就丟失，這意味着udp根本不會粘包，可是會丟數據，不可靠

tcp的協議數據不會丟，沒有收完包，下次接收，會繼續上次繼續接收，己端老是在收到ack時纔會清除緩衝區內容。數據是可靠的，可是會粘包。

socketserver實現併發

基於tcp的套接字，關鍵就是兩個循環，一個連接循環，一個通訊循環

socketserver模塊中分兩大類：server類（解決連接問題）和request類（解決通訊問題）

服務端：

 1 import socketserver
 2 
 3 class MyServer(socketserver.BaseRequestHandler):
 4 
 5     def handle(self): #進行通訊循環
 6         print('雙向鏈接:', self.request)
 7         print('客戶端地址:', self.client_address)
 8         print('套接字對象:', self.server)
 9 
10         while True:
11             try:
12                 # 收
13                 rec_msg = self.request.recv(1024)
14                 if not rec_msg:break
15                 print('客戶端傳來的消息是：', rec_msg)
16 
17                 # 發
18                 self.request.sendall(rec_msg.upper())
19             except Exception as err:
20                 print(err)
21                 break
22 
23 if __name__ == '__main__':
24     s = socketserver.ThreadingTCPServer(('192.168.0.106', 6060), MyServer) #進行鏈接循環,實現併發
25     s.serve_forever()

from socket import *

ip_port = ('192.168.0.106', 6060)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:
    msg = input('請輸入-->')
    if not msg:continue
    tcp_client.send(msg.encode('utf-8'))
    print('客戶端a發送成功')
    rev_msg = tcp_client.recv(buffer_size)
    print('從服務端收到的消息：', rev_msg.decode('utf-8'))

tcp_client.close()

客戶端

基於tcp的socketserver咱們本身定義的類中的

　　self.server即套接字對象
　　self.request即一個連接
　　self.client_address即客戶端地址

基於udp的socketserver咱們本身定義的類中的

　　self.request是一個元組（第一個元素是客戶端發來的數據，第二部分是服務端的udp套接字對象），如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
　　self.client_address即客戶端地址

認證客戶端的合法性

若是你想在分佈式系統中實現一個簡單的客戶端連接認證功能，又不像SSL那麼複雜，那麼利用hmac+加鹽的方式來實現

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 from socket import *
 4 import hmac,os
 5 
 6 secret_key=b'linhaifeng bang bang bang'
 7 def conn_auth(conn):
 8     '''
 9     認證客戶端連接
10     :param conn:
11     :return:
12     '''
13     print('開始驗證新連接的合法性')
14     msg=os.urandom(32)
15     conn.sendall(msg)
16     h=hmac.new(secret_key,msg)
17     digest=h.digest()
18     respone=conn.recv(len(digest))
19     return hmac.compare_digest(respone,digest)
20 
21 def data_handler(conn,bufsize=1024):
22     if not conn_auth(conn):
23         print('該連接不合法,關閉')
24         conn.close()
25         return
26     print('連接合法,開始通訊')
27     while True:
28         data=conn.recv(bufsize)
29         if not data:break
30         conn.sendall(data.upper())
31 
32 def server_handler(ip_port,bufsize,backlog=5):
33     '''
34     只處理連接
35     :param ip_port:
36     :return:
37     '''
38     tcp_socket_server=socket(AF_INET,SOCK_STREAM)
39     tcp_socket_server.bind(ip_port)
40     tcp_socket_server.listen(backlog)
41     while True:
42         conn,addr=tcp_socket_server.accept()
43         print('新鏈接[%s:%s]' %(addr[0],addr[1]))
44         data_handler(conn,bufsize)
45 
46 if __name__ == '__main__':
47     ip_port=('127.0.0.1',9999)
48     bufsize=1024
49     server_handler(ip_port,bufsize)

服務端

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 from socket import *
 4 import hmac,os
 5 
 6 secret_key=b'linhaifeng bang bang bang'
 7 def conn_auth(conn):
 8     '''
 9     驗證客戶端到服務器的連接
10     :param conn:
11     :return:
12     '''
13     msg=conn.recv(32)
14     h=hmac.new(secret_key,msg)
15     digest=h.digest()
16     conn.sendall(digest)
17 
18 def client_handler(ip_port,bufsize=1024):
19     tcp_socket_client=socket(AF_INET,SOCK_STREAM)
20     tcp_socket_client.connect(ip_port)
21 
22     conn_auth(tcp_socket_client)
23 
24     while True:
25         data=input('>>: ').strip()
26         if not data:continue
27         if data == 'quit':break
28 
29         tcp_socket_client.sendall(data.encode('utf-8'))
30         respone=tcp_socket_client.recv(bufsize)
31         print(respone.decode('utf-8'))
32     tcp_socket_client.close()
33 
34 if __name__ == '__main__':
35     ip_port=('127.0.0.1',9999)
36     bufsize=1024
37     client_handler(ip_port,bufsize)

客戶端(合法)

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *

def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    client_handler(ip_port,bufsize)

客戶端(非法:不知道加密方式)

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Linhaifeng'
 3 from socket import *
 4 import hmac,os
 5 
 6 secret_key=b'linhaifeng bang bang bang1111'
 7 def conn_auth(conn):
 8     '''
 9     驗證客戶端到服務器的連接
10     :param conn:
11     :return:
12     '''
13     msg=conn.recv(32)
14     h=hmac.new(secret_key,msg)
15     digest=h.digest()
16     conn.sendall(digest)
17 
18 def client_handler(ip_port,bufsize=1024):
19     tcp_socket_client=socket(AF_INET,SOCK_STREAM)
20     tcp_socket_client.connect(ip_port)
21 
22     conn_auth(tcp_socket_client)
23 
24     while True:
25         data=input('>>: ').strip()
26         if not data:continue
27         if data == 'quit':break
28 
29         tcp_socket_client.sendall(data.encode('utf-8'))
30         respone=tcp_socket_client.recv(bufsize)
31         print(respone.decode('utf-8'))
32     tcp_socket_client.close()
33 
34 if __name__ == '__main__':
35     ip_port=('127.0.0.1',9999)
36     bufsize=1024
37     client_handler(ip_port,bufsize)