2. 程式人生 > >網絡編程（三）——通信循環、鏈接循環、粘包問題

網絡編程（三）——通信循環、鏈接循環、粘包問題

阿新 • • 發佈：2018-09-03
res font 優化算法 exce erro recv data name 機制

通信循環、鏈接循環、粘包問題

一、通信循環

服務端和客戶端可以進行連續的信息交流

技術分享圖片 
from socket import *

ser_socket = socket(AF_INET, SOCK_STREAM)

ser_socket.bind((‘127.0.0.1‘, 8886))

ser_socket.listen(5)

conn, addr = ser_socket.accept()

while True:
    try:               # 拋出異常，若不拋出處理，一旦客戶端強行退出，服務端就會報錯
        data = conn.recv(1024)
        
 
print(data.decode(‘utf-8‘))

        conn.send(data.upper())
    except ConnectionResetError:
        break

conn.close()

ser_socket.close()
通信循環服務端 技術分享圖片 
from socket import *

cli_socket = socket(AF_INET, SOCK_STREAM)

cli_socket.connect((‘127.0.0.1‘, 8886))

#通信循環，可以多次輸入
while True:
    msg = input(‘>>>>:
 
‘).strip()
    if len(msg) == 0:            # 如果輸入為空，給服務端發送信息之後，服務端什麽都沒接受，一直處於阻塞狀態
        continue
    cli_socket.send(msg.encode(‘utf-8‘))

    data = cli_socket.recv(1024)
    print(data.decode(‘utf-8‘))

cli_socket.close()
通信循環客戶端

tcp是基於數據流的，於是收發的消息不能為空，這就需要在客戶端和服務端都添加空消息的處理機制

二、鏈接循環

可以啟動多個客戶端，但是只有一個客戶端是處於連接狀態，其余部分在半連接池等待連接，等待的數量不能超過半連接池的最大監聽數量

技術分享圖片 
from socket import *

ser_socket = socket(AF_INET, SOCK_STREAM)

ser_socket.bind((‘127.0.0.1‘, 8886))

ser_socket.listen(5)


#鏈接循環，可以同時啟動最多6個客戶端，但是只有一個處於連接狀態，其余最多5個在半連接池等待。只有當連接狀態的客戶端斷開連接，下一個客戶端才進入連接
while True:
    conn, addr = ser_socket.accept()

    # 通信循環
    while True:
        try:
            data = conn.recv(1024)
            print(data.decode(‘utf-8‘))

            conn.send(data.upper())
        except ConnectionResetError:
            break

    conn.close()

ser_socket.close()
鏈接循環服務端 技術分享圖片 
from socket import *

cli_socket = socket(AF_INET, SOCK_STREAM)

cli_socket.connect((‘127.0.0.1‘, 8886))

while True:
    msg = input(‘>>>>:‘).strip()
    if len(msg) == 0:
        continue
    cli_socket.send(msg.encode(‘utf-8‘))

    data = cli_socket.recv(1024)
    print(data.decode(‘utf-8‘))

cli_socket.close()
鏈接循環客戶端

三、粘包問題

1、模擬ssh遠程執行命令

技術分享圖片 
from socket import socket, AF_INET, SOCK_STREAM
import subprocess

ser_socket = socket(AF_INET, SOCK_STREAM)

ser_socket.bind((‘127.0.0.1‘, 8882))

ser_socket.listen(5)
while True:
    conn, addr = ser_socket.accept()
    while True:
        try:
            data = conn.recv(1024)
            obj = subprocess.Popen(data.decode(‘utf-8‘), 
                                   shell=True, 
                                   stdout=subprocess.PIPE, 
                                   stderr=subprocess.PIPE)
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            conn.send(stdout + stderr)
        except ConnectionResetError:
            break
    conn.close()

ser_socket.close()
服務端 技術分享圖片 
from socket import socket, AF_INET, SOCK_STREAM

cli_socket = socket(AF_INET, SOCK_STREAM)

cli_socket.connect((‘127.0.0.1‘, 8882))

while True:
    msg = input(‘>>>‘).strip()
    if len(msg) == 0:
        continue
    cli_socket.send(msg.encode(‘utf-8‘))
    data = cli_socket.recv(1024)
    print(data.decode(‘gbk‘))      #  Windows系統，默認編碼gbk,所以用gbk解碼

cli_socket.close()
客戶端

2、產生粘包原因

（1）所謂粘包問題主要還是因為接收方不知道消息之間的界限，不知道一次性提取多少字節的數據所造成的。

（2）此外，發送方引起的粘包是由TCP協議本身造成的，TCP為提高傳輸效率，發送方往往要收集到足夠多的數據後才發送一個TCP段。若連續幾次需要send的數據都很少，通常TCP會根據優化算法把這些數據合成一個TCP段後一次發送出去，這樣接收方就收到了粘包數據。

在上面的例子中，如果執行命令tasklist，那麽就會存在粘包問題。由於TCP協議是流式協議，所以數據都以流的形式傳輸。假如數據大小是123456，可是已經設定了接收的大小 是1024，所以只接受了數據中的一小部分，但是，剩余部分數據並不會消失，會一直存在於操作系統中，所以下一次接收數據的時候是優先從剩余數據中接收。這樣所有數據就亂套了，這就是粘包問題。

3、發生粘包的兩種情況

（1）發送端需要等緩沖區滿才發送出去，造成粘包（發送數據時間間隔很短，數據了很小，會合到一起，產生粘包）

技術分享圖片 
from socket import *

ser_socket = socket(AF_INET, SOCK_STREAM)

ser_socket.bind((‘127.0.0.1‘, 8886))

ser_socket.listen(5)

conn, addr = ser_socket.accept()

data = conn.recv(1024)
print(‘第一次接收：‘, data.decode(‘utf-8‘))
data1 = conn.recv(5)
print(‘第二次接收：‘, data1.decode(‘utf-8‘))
data2 = conn.recv(1024)
print(‘第三次接收：‘, data2.decode(‘utf-8‘))

conn.send(data.upper())

conn.close()

ser_socket.close()
服務端 技術分享圖片 
from socket import *

cli_socket = socket(AF_INET, SOCK_STREAM)

cli_socket.connect((‘127.0.0.1‘, 8886))

cli_socket.send(‘hello‘.encode(‘utf-8‘))
cli_socket.send(‘world‘.encode(‘utf-8‘))
cli_socket.send(‘object‘.encode(‘utf-8‘))

# data = cli_socket.recv(1024)
# print(data.decode(‘utf-8‘))

cli_socket.close()
客戶端

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

　　例如：模擬ssh遠程執行命令，若執行tasklist命令，在客戶端，無法幾次性全部接受執行結果，所以剩余結果會在下一次執行命令式優先接收

技術分享圖片 
from socket import socket, AF_INET, SOCK_STREAM
import subprocess

ser_socket = socket(AF_INET, SOCK_STREAM)

ser_socket.bind((‘127.0.0.1‘, 8882))

ser_socket.listen(5)
while True:
    conn, addr = ser_socket.accept()
    while True:
        try:
            data = conn.recv(1024)
            obj = subprocess.Popen(data.decode(‘utf-8‘),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            conn.send(stdout + stderr)
        except ConnectionResetError:
            break
    conn.close()

ser_socket.close()
服務端 技術分享圖片 
from socket import socket, AF_INET, SOCK_STREAM

cli_socket = socket(AF_INET, SOCK_STREAM)

cli_socket.connect((‘127.0.0.1‘, 8882))

while True:
    msg = input(‘>>>‘).strip()
    if len(msg) == 0:
        continue
    cli_socket.send(msg.encode(‘utf-8‘))
    data = cli_socket.recv(1024)
    print(data.decode(‘gbk‘))

cli_socket.close()
客戶端

4、解決粘包問題的方法

問題的根源在於，接收端不知道發送端將要傳送的字節流的長度，所以解決粘包的方法就是圍繞，如何讓發送端在發送數據前，把自己將要發送的字節流總大小讓接收端知曉，然後接收端來一個死循環接收完所有數據。為字節流加上自定義固定長度報頭，報頭中包含字節流長度，然後一次send到對端，對端在接收時，先從緩存中取出定長的報頭，然後再取真實數據。

（1）簡單版本

技術分享圖片 
# 服務端必須滿足至少三點:
# 1. 綁定一個固定的ip和port
# 2. 一直對外提供服務,穩定運行
# 3. 能夠支持並發
from socket import *
import subprocess
import struct

server = socket(AF_INET, SOCK_STREAM)
server.bind((‘127.0.0.1‘, 8081))
server.listen(5)

# 鏈接循環
while True:
    conn, client_addr = server.accept()
    print(client_addr)

    # 通信循環
    while True:
        try:
            cmd = conn.recv(1024) #cmd=b‘dir‘
            # if len(cmd) == 0: break  # 針對linux系統
            obj=subprocess.Popen(cmd.decode(‘utf-8‘),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )
            stdout=obj.stdout.read()
            stderr=obj.stderr.read()
            # 1. 先制作固定長度的報頭
            header=struct.pack(‘i‘,len(stdout) + len(stderr))
            # 2. 再發送報頭
            conn.send(header)
            # 3. 最後發送真實的數據
            conn.send(stdout)
            conn.send(stderr)
        except ConnectionResetError:
            break

    conn.close()

server.close()
服務端 技術分享圖片 
from socket import *
import struct

client = socket(AF_INET, SOCK_STREAM)
client.connect((‘127.0.0.1‘, 8081))

# 通信循環
while True:
    cmd=input(‘>>: ‘).strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode(‘utf-8‘))
    #1. 先收報頭,從報頭裏解出數據的長度
    header=client.recv(4)
    total_size=struct.unpack(‘i‘,header)[0]
    #2. 接收真正的數據
    cmd_res=b‘‘
    recv_size=0
    while recv_size < total_size:
        data=client.recv(1024)
        recv_size+=len(data)
        cmd_res+=data

    print(cmd_res.decode(‘gbk‘))

client.close()
客戶端

（2）終極版本

技術分享圖片 
# 服務端必須滿足至少三點:
# 1. 綁定一個固定的ip和port
# 2. 一直對外提供服務,穩定運行
# 3. 能夠支持並發
from socket import *
import subprocess
import struct
import json

server = socket(AF_INET, SOCK_STREAM)
server.bind((‘127.0.0.1‘, 8081))
server.listen(5)

# 鏈接循環
while True:
    conn, client_addr = server.accept()
    print(client_addr)

    # 通信循環
    while True:
        try:
            cmd = conn.recv(1024)  # cmd=b‘dir‘
            if len(cmd) == 0: break  # 針對linux系統
            obj = subprocess.Popen(cmd.decode(‘utf-8‘),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE
                                   )
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()
            # 1. 先制作報頭
            header_dic = {
                ‘filename‘: ‘a.txt‘,
                ‘md5‘: ‘asdfasdf123123x1‘,
                ‘total_size‘: len(stdout) + len(stderr)
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode(‘utf-8‘)

            # 2. 先發送4個bytes(包含報頭的長度)
            conn.send(struct.pack(‘i‘, len(header_bytes)))
            # 3  再發送報頭
            conn.send(header_bytes)

            # 4. 最後發送真實的數據
            conn.send(stdout)
            conn.send(stderr)
        except ConnectionResetError:
            break

    conn.close()

server.close()
服務端 技術分享圖片 
from socket import *
import struct
import json

client = socket(AF_INET, SOCK_STREAM)
client.connect((‘127.0.0.1‘, 8081))

# 通信循環
while True:
    cmd=input(‘>>: ‘).strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode(‘utf-8‘))
    #1. 先收4bytes,解出報頭的長度
    header_size=struct.unpack(‘i‘,client.recv(4))[0]

    #2. 再接收報頭,拿到header_dic
    header_bytes=client.recv(header_size)
    header_json=header_bytes.decode(‘utf-8‘)
    header_dic=json.loads(header_json)
    print(header_dic)
    total_size=header_dic[‘total_size‘]

    #3. 接收真正的數據
    cmd_res=b‘‘
    recv_size=0
    while recv_size < total_size:
        data=client.recv(1024)
        recv_size+=len(data)
        cmd_res+=data

    print(cmd_res.decode(‘gbk‘))

client.close()
客戶端

網絡編程（三）——通信循環、鏈接循環、粘包問題

相關推薦

網絡編程（三）——通信循環、鏈接循環、粘包問題

res font 優化算法 exce erro recv data name 機制 通信循環、鏈接循環、粘包問題 一、通信循環 服務端和客戶端可以進行連續的信息交流 from socket import * ser_socket = socket(AF_INET, S

c++ 網絡編程（三）TCP/IP 進程間的通信原理與實現代碼

ech nbsp 傳遞數據 lse sock cnblogs 實例代碼 remove %s 原文作者：aircraft 原文鏈接：https://www.cnblogs.com/DOMLX/p/9613027.html 一.進程間通信的基本概念 進程間通信意味著兩個

12.5-全棧Java筆記:Java網絡編程（三）

java上節回顧：在學習了Socket在建立客戶端和服務器單項通訊中，分別創建獨立的Socket，並通過Socket的屬性。那麽如何將兩個Socket進行連接，從而達到客戶端和服務器之間建立輸入輸出流進行通信呢？在上節中我們已經講到，TCP/IP套接字是最可靠的雙向流協議，使用TCP/IP可以發送任意數量的數

Socket網絡編程（三）

shu style ava socket lin 客戶端 finally accep span TCP協議網絡通訊案例（http協議） 1、創建TcpServer（tcp服務端） package com.cppdy.tcp; import java.io.IOExcep

------------------------------------網絡編程（Socket）(TCP )

bin 通信 主機 cnblogs 連接 add edr 監聽 .so 1.Java.net 包提供若幹支持基於套接字的客戶端/服務器通信的類。 2.java.net包中常有的類有Socket、ServerSocket、DatagramPacket、InetAddress、

Linux網絡編程（3）——多進程、多線程

ssh pri turn null client 技術分享 malloc tle () 在我的裏面已經介紹了linux以下c的進程、線程接口，這裏就不做過多闡述了。 多進程 這裏多進程採用傳統的多進程模型。每當有client發來的連接時創建一個進程來處理連接，一個

Java基礎——網絡編程（一）

orm server ip地址 尋址 ans http1 端口 分割線 查看 本文主要記錄網絡編程的一些基礎知識，學了前班部分，對專業術語有些蒙，但是，收貨也是很多很多的。觀察了自己計算機的進程，查找其他網絡地址的IP，對互聯網的層次關系有了更深一步的了解。下面多是概念的摘

Android網絡編程（一）HTTP協議原理

客戶 獲取版本 接口 開發人員 linu 系統 拒絕 sts inter 相關文章 Android網絡編程（一）HTTP協議原理 Android網絡編程（二）HttpClient與HttpURLConnection Android網絡編程（三）V

Python學習筆記（四十五）網絡編程（1）TCP編程

包含 ipv sina spa 包括 現在 com 訪問 等等 摘抄：https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001432004374523e49

python全棧開發基礎【第十八篇】網絡編程（socket）

回復 pro 解決 gettime connect 問題： 發送 lose post 一、網絡協議 客戶端/服務器架構 1.硬件C/S架構（打印機） 2.軟件C/S架構（互聯網中處處是C/S架構）：B/S架構也是C/S架構的一種，B/S是瀏覽器/服務器 C/S架構與sock

網絡駭客入門之網絡編程（一）：網絡應知應會

網絡網絡駭客入門之網絡編程（一）：網絡應知應會一、計算機網絡在設計之初就決定了它結構簡單，傳輸可靠的特點，除此之外，它還能連接不同種類的計算機在網絡上，各個節點同等重要且必須有冗余路由二、網絡在理論上被分為七層，從下到上，物理層，數據鏈路層，網絡層，傳輸層，會話層，表示層，應用層在實際的應用上分為四層，即：鏈

python 網絡編程（Socket）

python recv ets forever AI AC sim 文件 執行 # from wsgiref.simple_server import make_server## def RunServer(environ,start_response):# sta

python網絡編程（一）

unix imp p地址 mail 傳輸層 很多 一個 說明 reat socket簡介 1.本地的進程間通信（IPC）有很多種方式，例如 隊列 同步（互斥鎖、條件變量等） 以上通信方式都是在一臺機器上不同進程之間的通信方式，那麽問題來了 網絡中進程之間如何通信？ 2.

python網絡編程（八）

IE finally 空閑 while 因此 ddr tcp服務器 隊列 %s 單進程服務器 1. 完成一個簡單的TCP服務器 from socket import * serSocket = socket(AF_INET, SOCK_STREAM) # 重復使用綁定

python網絡編程（六）

想要 打電話 HA ima 輸入數據 撥打 news 提示 構建 tcp通信模型 tcp服務器 在程序中，如果想要完成一個tcp服務器的功能，需要的流程如下： socket創建一個套接字 bind綁定ip和port listen使套接字變為可以被動鏈接 accept等待

小白學習之路，網絡編程（下）

多人 困難 get err lose imp 出現 popen one 一，socket進階 在前面的博客中講到了一些基本的計算機網絡知識，有一點也是為我在要考傳輸與交換看到一個題，然後就看到說ARP屬於網絡層，因為ARP協議跟網絡相關，但是我前面的博客說的是ARP協議屬於

網絡編程（二）——TCP協議、socket

cep 數據請求 b- aps pre alt 技術分享 隱藏 可靠 TCP協議與socket套接字 一、TCP協議 1、可靠傳輸，TCP數據包沒有長度限制，理論上可以無限長，但是為了保證網絡的效率，通常TCP數據包的長度不會超過IP數據包的長度，以確保單個TCP數據包不必

c++ 網絡編程（四）TCP/IP LINUX/windows下 socket 基於I/O復用的服務器端代碼 解決多進程服務端創建進程資源浪費問題

linux系統中 cin 通過 sel print 大小 查看 服務 集合 原文作者：aircraft 原文鏈接：https://www.cnblogs.com/DOMLX/p/9613861.html 好了，繼上一篇說到多進程服務端也是有缺點的，每創建一個

c++ 網絡編程（六）TCP/IP LINUX下 socket編程 多播與廣播 實現一次發送所有組客戶端都能接收到

send all users 代碼示例 proto 次數 不可 的人 ssa 原文作者：aircraft 原文鏈接：https://www.cnblogs.com/DOMLX/p/9614288.html 一.多播 鍥子：有這麽一種情況，網絡電臺可能需要同時向成

Java網絡編程（一）

第一個 jvm 本地 class 解決方案 *** ati 等待 輸入流 ***********************第15章 socket編程(網絡編程)************************ 網絡編程 != 網站編程 京東 淘寶 網站編程 網絡QQ---