2. 程式人生 > 實用技巧 >24、解決粘包問題的方法、UDP套接字簡單示例、多併發問題

24、解決粘包問題的方法、UDP套接字簡單示例、多併發問題

阿新 • • 發佈：2021-01-19

一、解決粘包問題的方法（簡單版）

  • 服務端
from socket import *
from subprocess import PIPE, Popen
import struct

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8000))
server.listen(5)

while True:
    conn, client_addr = server.accept()
    print(client_addr)

    while True:  # 通訊迴圈
        try:
            cmd = conn.recv(8096)
            if len(cmd) == 0:  # 針對於linux系統
                break
            obj = Popen(cmd.decode('utf-8'),
                        shell=True,
                        stderr=PIPE,
                        stdout=PIPE, )
            res1 = obj.stdout.read()
            res2 = obj.stderr.read()
            total_size = len(res1) + len(res2)

            # 先把資料的長度給發過去，長度為4
            header = struct.pack('i', total_size)
            conn.send(header)

            # 再發送真正的資料
            conn.send(res2)  # 利用TCP協議的特性
            conn.send(res1)  # nagle演算法規定，TCP協議會將資料量較小、
            # 時間間隔短的資料合併為一條傳送給客戶端
        except Exception:
            break
    conn.close()  # 異常斷開後回收資源
  • 客戶端
from socket import *
from subprocess import PIPE, Popen
import struct

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8000))

while True:
    cmd = input('>>>:').strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))

    # 先接收資料的長度
    header = client.recv(4)
    total_size = struct.unpack('i', header)[0]  # 提取出位元組長度

    # 接收真正的資料
    recv_size = 0
    res = b''
    while recv_size < total_size:
        data = client.recv(1024)
        recv_size += len(data)
        res += data
    print(res.decode('gbk'))

二、解決粘包問題的方法（優化版）

  • 服務端
import json
from socket import *
import struct
from subprocess import PIPE, Popen

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8000))
server.listen(5)

while True:  # 連結迴圈
    conn, client_addr = server.accept()
    print(client_addr)

    while True:  # 通訊迴圈
        try:
            cmd = conn.recv(8096)
            if len(cmd) == 0:
                break
            obj = Popen(cmd.decode('utf-8'),
                        shell=True,
                        stdout=PIPE,
                        stderr=PIPE)
            res1 = obj.stdout.read()
            res2 = obj.stderr.read()

            header_dic = {
                'filename': 'a.txt',
                'total_size': len(res1) + len(res2),
                'md5': 'qwe165qwqwe65456qw5'
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('utf-8')

            # 先發四個位元組
            conn.send(struct.pack('i', len(header_bytes)))
            # 再發報頭字典
            conn.send(header_bytes)

            # 最後發真正的資料
            conn.send(res1)
            conn.send(res2)
        except Exception:
            break
    conn.close()  # 關閉視窗來回收資源
  • 客戶端
from socket import *
import struct
import json

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8000))

while True:
    cmd = input('>>>: ').strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))

    # 先接收四個位元組，提取header_bytes的長度
    header_bytes_len = struct.unpack('i', client.recv(4)[0])
    # 再收header_bytes,提取header_dic
    header_bytes = client.recv(header_bytes_len)
    header_json = header_bytes.decode('utf-8')
    header_dic = json.loads(header_json)
    print(header_json)
    total_size = header_dic['total_size']

    # 再接收真正的資料
    recv_size = 0
    res = b''
    while recv_size < total_size:
        data = client.recv(1024)
        recv_size += len(data)
        res += data

    print(res.decode('gbk'))

三、基於UDP套接字的編寫

  • 服務端
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 造手機
server.bind(('127.0.0.1', 8000))  # 需要繫結，不許要監聽
while True:  # 通訊迴圈
    data, client_addr = server.recvfrom(1024)
    # 解壓賦值（文字，傳送端的埠號）
    print(data)
    server.sendto(data.upper(), client_addr)
  • 客戶端
from socket import *

client = socket(AF_INET, SOCK_DGRAM)  # 造手機
while True:  # 輸入迴圈
    msg = input('輸入：').strip()
    client.sendto(msg.encode('utf8'), ('127.0.0.1', 8000))
    # sendto（傳送內容二進位制，接收埠）
    data, client_addr = client.recvfrom(1024)
    # 解壓賦值（接收的文字，埠）
    print(data.decode('utf-8'))
  • UDP協議一般不會用於大資料的傳輸
  • UDP套接字雖然沒有粘包的問題，但是不能代替TCP套接字，因為UDP協議有一個缺陷，如果資料傳送的途中，資料丟失，則資料就丟失了，而TCP協議則不會有這種缺陷，因此一般的UDP套接字使用者無關緊要的資料傳送，例如QQ、微信聊天等.

四、socketserver模組

  • 基本使用框架
import socketserver


class MyHandler(socketserver.BaseRequestHandler):
    # 通訊迴圈
    def handle(self):  # 呼叫的話以上不變
        # data = self.request.recv(1024)  # self.recv(1024)
        # print(data)
        # self.request.send(data.upper())

        if __name__ == '__main__':
            server = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyHandler, bind_and_activate=True)
            server.serve_forever()
  • 多併發——服務端
# 同一時刻有多個人在接聽
import socketserver
import json
from subprocess import Popen, PIPE
import struct


class MyHandler(socketserver.BaseRequestHandler):
    # 通訊迴圈
    def handle(self):  # 呼叫的話以上不變
        # data = self.request.recv(1024)  # self.recv(1024)
        # print(data)
        # self.request.send(data.upper())
        try:
            cmd = self.request.recv(8096)
            obj = Popen(cmd.decode('utf-8'),
                        shell=True,
                        stdout=PIPE,
                        stderr=PIPE,
                        )

            res1 = obj.stdout.read()
            res2 = obj.stderr.read()

            header_dic = {
                'filename': "a.txt",
                'total_size': len(res1) + len(res2),
                'md5': '123dfsfsaf123213'
            }

            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('utf-8')

            # 先發4個位元組
            self.request.send(struct.pack('i', len(header_bytes)))
            # 再發報頭字典
            self.request.send(header_bytes)

            # 最後傳送真正的資料
            self.request.send(res1)
            self.request.send(res2)
        except Exception:
            self.request.close()


# 使用socketserver的連線迴圈（併發），但是使用了自己的通訊迴圈

if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyHandler, bind_and_activate=True)
    server.serve_forever()

# 呼叫的話只需要將conn改成self.request即可
  • 多併發——客戶端1
from socket import *
import struct
import json

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8080))

while True:
    cmd = input(">>>: ").strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))

    # 先收4個位元組,提取header_bytes的長度
    header_bytes_len = struct.unpack('i', client.recv(4))[0]


    # 再收header_bytes，提取header_dic
    header_bytes = client.recv(header_bytes_len)
    header_json = header_bytes.decode('utf-8')
    header_dic = json.loads(header_json)

    print(header_dic)

    total_size = header_dic['total_size']

    # 再接收真正的資料
    recv_size = 0
    res = b''
    while recv_size < total_size:
        data = client.recv(1024)
        recv_size += len(data)
        res += data

    print(res.decode('gbk'))
  • 多併發——客戶端2
from socket import *
import struct
import json

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8080))

while True:
    cmd = input(">>>: ").strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))

    # 先收4個位元組,提取header_bytes的長度
    header_bytes_len = struct.unpack('i', client.recv(4))[0]


    # 再收header_bytes，提取header_dic
    header_bytes = client.recv(header_bytes_len)
    header_json = header_bytes.decode('utf-8')
    header_dic = json.loads(header_json)

    print(header_dic)

    total_size = header_dic['total_size']

    # 再接收真正的資料
    recv_size = 0
    res = b''
    while recv_size < total_size:
        data = client.recv(1024)
        recv_size += len(data)
        res += data

    print(res.decode('gbk'))

相關推薦

24、解決粘包問題的方法、UDP套接字簡單示例、多併發問題

一、解決粘包問題的方法（簡單版） 服務端 from socket import * from subprocess import PIPE, Popen

UDP套接字通訊、socketserver併發程式設計

目錄UDP套接字通訊、socketserver併發程式設計一 基於UDP的套接字通訊1 TCP與UDP協議的對比2 基於UDP的套接字基本模板2.1 udp服務端2.2 udp客戶端3 UDP套接字簡單示例3.1 udp服務端3.2 udp客戶端二 基於socketserver

基於socketserver模組實現併發tcp套接字通訊 ，基於socketserver模組實現併發udp套接字通訊

二、基於socketserver模組實現併發tcp套接字通訊 #server # from socket import * # # # server=socket(AF_INET,SOCK_STREAM)

網路通訊——udp套接字

1. 軟體開發架構 C/S架構 client 　　客戶端 server　服務端 B/S架構 browser 瀏覽器 server 伺服器

socket基礎——udp套接字

技術標籤：socketlinux網路python socket基礎 首先匯入socket庫 import socket 建立一個udp套接字

TCP,UDP,套接字，dns域名解析，交換機與vlan，dhcp協議

Udp與Tcp # 上一章講了tcp的三次握手以及四次揮手 # OSI七層模型裡面傳輸層的代表協議除了tcp還有個udp。

《Unix 網路程式設計》08：基本UDP套接字程式設計

基本UDP套接字程式設計 系列文章導航：《Unix 網路程式設計》筆記 UDP 概述 流程圖

TCP 協議如何解決粘包、半包問題

一、TCP 協議是流式協議 　　很多讀者從接觸網路知識以來，應該聽說過這句話：TCP 協議是流式協議。那麼這句話到底是什麼意思呢？所謂流式協議，即協議的內容是像流水一樣的位元組流，內容與內容之間沒有明確的分界

使用Dotnetty解決粘包問題

一，為什麼TCP會有粘包和拆包的問題 粘包：TCP傳送方傳送多個數據包，接收方收到資料時這幾個資料包粘成了一個包，從接收緩衝區看，後一包資料的頭緊接著前一包資料的尾，接收方必需根據協議將這幾個資料包分離出來才

JAVA基礎知識點21-網路程式設計、IP、埠、統一資源定位符(URL)、協議、套接字、UDP、反射

技術標籤：Javase基礎知識點java反射網路socket IP、埠： IP: 定義節點 IPV4 : 4個位元組32位

網路模型、scoket套接字、udp概念及程式碼實現、tcp概念及程式碼實現

網路模型的概念： 　　OSI七層模型(應表會傳網數物) 　　　　7.應用層　　　　6.表示層　　　　5.會話層　　　　4.傳輸層　　　　3.網路層　　　　2.資料鏈路層　　　　1.物理層

Netty解決粘包和拆包問題的四種方案

在RPC框架中，粘包和拆包問題是必須解決一個問題，因為RPC框架中，各個微服務相互之間都是維繫了一個TCP長連線，比如dubbo就是一個全雙工的長連線。由於微服務往對方傳送資訊的時候，所有的請求都是使用的同一個連線

Java學習筆記（21）——網路程式設計（套接字）、TCP、UDP、簡易聊天程式

技術標籤：Java學習欄目網路socketjava網路通訊網路協議 網路程式設計（套接字）

socket套接字、通訊迴圈、連結迴圈和黏包問題

一、socket套接字 二、通訊迴圈 三、程式碼優化和連結迴圈 四、黏包問題 一、socket套接字

MySQL(InnoDB剖析):03---MySQL的連線與通訊方式（程序間通訊(管道、套接字、UNIX域套接字)）

一、MySQL的連線與通訊方式 連線MySQL操作時一個連線程序和MySQL資料庫例項進行通訊的過程

Socket基礎六：基於資料報套接字的網路程式（udp丟包測試）

技術標籤：Windows Socket網路socket Socket基礎五：基於資料報套接字的網路程式（udp丟包測試）

二、asio使用教程--套接字

使用TCP實現daytime協議 同步的daytime客戶端 利用asio實現一個TCP的客戶端應用。 引入標頭檔案

mybatis、sql、logback等配置及資料增刪改查的簡單示例

資料持久層框架mybatis的應用 Mybatis和logback的應用配置 配置pom.xml檔案： <?xml version=\"1.0\" encoding=\"UTF-8\"?>

Error: [WinError 10013] 以一種訪問許可權不允許的方式做了一個訪問套接字的嘗試及其解決方法

Error: [WinError 10013] 以一種訪問許可權不允許的方式做了一個訪問套接字的嘗試及其解決方法 

網路程式設計、Socket套接字程式設計

網路程式設計 內容介紹 網路通訊協議 UDP通訊 TCP通訊 內容學習目標 能夠獨立完成“檔案上傳”案例的原始碼編寫、編譯、執行的操作