Python-面向網絡編程-socket原理

socket

　　整個計算機網絡是由協議構成，想要通訊必須遵照對應的協議，如Web中的http協議、傳輸協議TCP和UDP等等。在網絡工程師的眼中，可能如今網絡上的一切都是socket，一切皆socket，咱們通常接觸到的是應用層應用程序，本質上兩個應用想通訊，則必須經過socket實現通訊，socket直接和傳輸層後下面的底層網絡協議打交道(socket自己讓咱們直接與TCP打交道)，底層socket已經創建好則能夠互相通訊。互聯網如今主流的網絡層協議是IPv4，IPv6是下一代網絡層協議但不主流，IPv6解決的是IPv4地址耗盡的問題，其實爲了應對IPv4資源少的問題產生了局域網和網關。

 

網絡模型

　　其發展過程，是一次解決需求的迭代過程。當計算機剛發明並投入使用，兩臺計算機想實現點對點通訊，因而產生了數據鏈路層，當加入更多的計算機實現通訊的時候，就產生了網絡層，實現通訊還不能知足需求，須要經過網絡傳輸數據，則產生了傳輸層，對於可靠性的需求產生了TCP和UDP兩種傳輸協議，不一樣的用戶有不一樣的需求，因而應用層就被劃分出來了。用戶在應用層使用各類app，數據依次往下組包直至物理層發送到網絡，接收數據則往上拆包獲得最終數據。本質上是需求推進了網絡層次的產生，當前把網絡七層模型中的會話、表示、應用層統稱爲應用層。

　　應用層 　　　　 文件傳輸、文件服務、電子郵件 http ftp smtp dns
　　傳輸層 　　　　 經過端對端的接口 TCP UDP
　　網絡層 　　　　 爲數據包選擇路由 IP ICMP
　　數據鏈路層　　  傳輸有地址的幀、錯誤檢測功能 ARP
　　物理層 　　　　 物理媒體

 

北門吹雪：http://www.cnblogs.com/2bjiujiu/

　　

通常創建在socket上通訊的應用都採用C/S模型，這裏來理清C/S架構

客戶端： 

　　須要申明協議、請求創建鏈接、發送和接收數據、關閉鏈接這些過程

　　

 

服務端： 

　　申明協議實例監聽者（來源三體）、綁定監聽IP和端口、啓動監聽者監聽、創建鏈接、接收和發送數據、斷開鏈接這些過程

　　# 下面這個是單線程服務端監聽者實例過程

　　　　

 

客戶端實例實現過程

import socket
import time


def beimenchuixue_client():
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect(('127.0.0.1', 8000))
    while True:
        data = input("北門吹雪:")
        if not data.strip():
            continue
        client.send(data.encode('utf-8'))
        response = client.recv(1024)
        print(response.decode('utf-8'))


if __name__ == '__main__':
    print("北門吹雪: http://www.cnblogs.com/2bjiujiu/")
    while True:
        # 一個小重啓
        try:
            beimenchuixue_client()
        except ConnectionResetError as e:
            time.sleep(2)

 

單線程客戶端監聽者實例實現過程

import socket


def beimenchuixue_alone_socket():
    listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listener.bind(('0.0.0.0', 8000))
    listener.listen()
    while True:
        conn, remote_address = listener.accept()
        print("%s:%s 創建鏈接" % remote_address)
        while True:
            # 處理客戶端端口異常
            try:
                data = conn.recv(1024).decode("utf-8")
            except ConnectionResetError as e:
                print("%s:%s 斷開鏈接" % remote_address)
                conn.close()
                break
            conn.send(bytes(data.upper(), encoding='utf-8'))


if __name__ == '__main__':
    print("北門吹雪: http://www.cnblogs.com/2bjiujiu/")
    beimenchuixue_alone_socket()

　　#  這個服務端實現了把小寫轉換爲大寫的服務，其餘客戶端鏈接來須要排隊等待正在處理的客戶端斷開請求，也就是其餘客戶端進入堵塞狀態

 

 北門吹雪：http://www.cnblogs.com/2bjiujiu/

 

多線程或協程處理鏈接請求架構圖

　　　　

　　線程處理鏈接架構圖

　　

 

多線程客戶端監聽者實例實現過程

import socket
from threading import Thread


def beimenchuixue_handler(conn, remote_address):
    """線程處理處理每一個鏈接"""
    # 處理客戶端斷開異常
    while True:
        try:
            data = conn.recv(1024).decode("utf-8")
        except ConnectionResetError as e:
            print("%s:%s 斷開鏈接" % remote_address)
            break
        conn.send(bytes(data.upper(), encoding='utf-8'))
    conn.close()


def beimenchuixue_socket():
    listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listener.bind(('0.0.0.0', 8000))
    listener.listen()
    while True:
        conn, remote_address = listener.accept()
        print("%s:%s 創建鏈接" % remote_address)
        handler = Thread(target=beimenchuixue_handler, args=(conn, remote_address))
        handler.start()


if __name__ == '__main__':
    print("北門吹雪: http://www.cnblogs.com/2bjiujiu/")
    beimenchuixue_socket()

 

面向對象方式寫多線程socket

import socket
from threading import Thread


class BeiMenChuiXueHandle(Thread):
    def __init__(self, conn, remote_address):
        super().__init__()
        self.conn = conn
        self.remote_address = remote_address

    def run(self):
        while True:
            try:
                data = self.conn.recv(1024).decode("utf-8")
            except ConnectionResetError as e:
                print("北門吹雪")
                print("%s:%s 斷開鏈接" % self.remote_address)
                break
            self.conn.send(bytes(data.upper(), encoding='utf-8'))
        self.conn.close()


class BeiMenChuiXueHandleSocket:
    def __init__(self):
        self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    def _handle(self, conn, remote_address):
        handler = BeiMenChuiXueHandle(conn, remote_address)
        handler.start()

    def socket_run(self, ip, port):
        self.listener.bind((ip, port))
        self.listener.listen()
        while True:
            conn, remote_address = self.listener.accept()
            print("北門吹雪")
            print("%s:%s 創建鏈接" % remote_address)
            self._handle(conn, remote_address)


if __name__ == '__main__':
    listener = BeiMenChuiXueHandleSocket()
    listener.socket_run(ip='0.0.0.0', port=8000)

　　

協程方式寫socket(須要安裝協程模塊gevent，在Python3.5版本中自己就支持協程語義async await)

import socket
import gevent

from gevent import monkey


class BeiMenChuiXueSocket:
    def __init__(self, ip, port):
        # 自動標記堵塞，要放到全部堵塞實例以前
        monkey.patch_all()
        self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.ip = ip
        self.port = port

    def _handler(self, conn, remote_address):
        while True:
            try:
                data = conn.recv(1024).decode("utf-8")
            except ConnectionResetError as e:
                print("北門吹雪")
                print("%s:%s 斷開鏈接" % remote_address)
                break
            conn.send(bytes(data.upper(), encoding='utf-8'))
        conn.close()

    def forever_run(self):
        self.listener.bind((self.ip, self.port))
        self.listener.listen()
        while True:
            conn, remote_address = self.listener.accept()
            print("北門吹雪")
            print("%s:%s 創建鏈接" % remote_address)
            # 啓動協程處理鏈接
            gevent.spawn(self._handler, conn, remote_address)


if __name__ == '__main__':
    beimenchuixue = BeiMenChuiXueSocket('0.0.0.0', 8000)
    beimenchuixue.forever_run()

　　

經驗：

　　1. socket是網絡最爲基礎的通訊方式，也是上層應用的通訊基礎

　　2. 服務端爲了同時響應多個請求則能夠選擇進程、線程、協程等多種方式處理鏈接進來的請求，通常選擇線程或協程

　　3. CPython因爲GIL保證一顆核只能在同一時刻跑一個線程，多進程在某種意義上只是開啓了多個線程，而進程開銷這麼大，不是好方法，也就是說對Python的異步編程仍是要使用線程或者協程進行

　　4. Python線程、協程只適於IO密集型，不適用CPU密集型，因爲GIL的存在本質上是個單線程