socket

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

網絡模型

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

　　應用層 　　　　 文件傳輸、文件服務、電子郵件 http ftp smtp dns

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

一般建立在socket上通信的應用都采用C/S模型，這裏來理清C/S架構

客戶端：

　　需要申明協議、請求建立連接、發送和接收數據、關閉連接這些過程

服務端：

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

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

客戶端實例實現過程

import socket


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__‘:
    beimenchuixue_client()

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

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__‘:
    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__‘:
    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的存在本質上是個單線程

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