網絡編程總結

一.osi七層模型

應用層 http https ssl smtp ftp

表示層,會話層  

傳輸層 tcp udp   端口信息 四層路由器 四層交換機

# tcp
 # 可靠的 面向鏈接的 全雙工的 流式傳輸 效率低
 # 三次握手和四次揮手
 # 三次握手
 # 把圖背下來 syn ack
 # 四次揮手
 # 把圖背下來 fin ack
 # 黏包 : (自定義協議)先發送數據的長度,再發送數據
# udp 效率高 不可靠 無鏈接 基於數據包的傳輸 可以傳輸的數據的長度有限

 

網絡層  ipv4協議192.168.0.1 ipv6協議 ff2312:f5242:12:1:1:1 網關地址 子網掩碼 路由器 三層交換機

數據鏈路層 :arp (經過ip地址找到mac地址),rarp(經過mac地址找ip地址) 網卡 交換機

 

物理層

 

三次握手,四次揮手

 

 

 

 有syn  ack  fin  三種

 

手寫socket

# 手寫socket
# server - tcp
import socket
# sk = socket.socket()
# sk.bind(('127.0.0.1',9000))
# sk.listen()
#
# # while True表示可以和多個client通訊
# conn,adds = sk.accept()  # 創建三次握手的過程
# # while True表示可以和一個client說多句話
# conn.recv(1024)
# conn.send(b'xxx')
# conn.close()
# sk.close()  # 四次揮手中的兩手

# client -tcp
# import socket
# sk = socket.socket()
# sk.connect(('127.0.0.1',9000))
#
# sk.send(b'hello')
# sk.recv(1024)
# sk.close()   # 四次揮手中的兩手

# server -udp
# import socket
# sk = socket.socket(type=socket.SOCK_DGRAM)
# sk.bind(('127.0.0.1',9000))
# while True:
#     msg,cli_addr = sk.recvfrom(1024)
#     sk.sendto(msg,cli_addr)
# sk.close()

# clients -udp
# import socket
# sk = socket.socket(type=socket.SOCK_DGRAM)
# sk.sendto(b'msg',('127.0.0.1',9000))
# msg,_ = sk.recvfrom(1024)
# print(msg)
# sk.close()

操做系統:

異步同步\阻塞非阻塞\併發並行
併發和並行
並行 能利用多核 同一時刻 有多個任務在CPU上同時執行  多任務
併發 不能利用多核 同一時間段內 有多個任務在一個CPU上輪流被執行  一個cup一直使用

　同步和異步

同步 當我執行一個任務  須要等待這個任務的結果才能繼續執行下一個任務
異步 當我執行某一個任務 不須要等待這個任務的結果 就能夠繼續執行下一個任務

阻塞和非阻塞

非阻塞 : cpu一直在工做
阻塞 : CPU不工做 recv recvfrom accept input sleep

io操做

input : input read recv recvfrom accept connet close
output: write send sendto connet accept close

# 同步阻塞   等待不調度cup
# def func():
#     import time
#     time.sleep(1)
#
# def func2():
#     func()
#     print(123)
# func2()

# 同步非阻塞  等待調度cup
# def func():
#     a = 1
#     b= a+1
#     return b
# def func2():
#     func()
#     print(123)
# func2()

# 異步阻塞  不等待不調度cup
# import time
# import threading
# def func():
#     time.sleep(1)
# t_l = []
# for i in range(10):
#     t = threading.Thread(target=func)
#     t.start()
#     t_l.append(t)
# for t in t_l:t.join()


# 異步非阻塞
# 我調用一個函數 不等待這個函數的結果
# 而且我能一直利用cpu

 

 

 異步非阻塞:

異步:不等待結果

非阻塞:一致調度cpu

 

 關於io多路複用

做用:在windows中經過select 進行監控   linux 下經過pool  epool監控

# 操做系統中的IO多路複用
# select poll epoll
# select windows
# poll epoll linux
# epoll最好

 

# io多路複用
 # 代理全部的網絡對象,幫助咱們監聽有哪個對象發生了註冊事件(讀\寫\異常),而後通知程序,去進行相應的處理

# selectors模塊
# 可以有效的利用poll和epoll前提是你所在的操做系統是有這兩個機制的
# 自動的識別當前操做系統中咱們能用的最好的機制

select模塊使用

from socket import *
import selectors

sel=selectors.DefaultSelector()
def accept(sk,mask):
    conn,addr=sk.accept()
    sel.register(conn,selectors.EVENT_READ,read)

def read(conn,mask):
    try:
        data=conn.recv(1024)
        if not data:
            print('closing',conn)
            sel.unregister(conn)
            conn.close()
            return
        conn.send(data.upper()+b'_SB')
    except Exception:
        print('closing', conn)
        sel.unregister(conn)
        conn.close()

sk=socket(AF_INET,SOCK_STREAM)
sk.bind(('127.0.0.1',8088))
sk.listen(5)
sk.setblocking(False)

sel.register(sk,selectors.EVENT_READ,accept) #至關於網select的讀列表裏append了一個文件句柄server_fileobj,而且綁定了一個回調函數accept

while True:
    events=sel.select() # 代理在這裏等待,等events事件來,一旦等來了 那麼必定是有新的連接 來 或者是有發送給conn的數據來
    for sel_obj,mask in events:
        callback=sel_obj.data #callback=accpet/read
        callback(sel_obj.fileobj,mask) #accpet(server_fileobj,1)

 

# select 只能使用select
# selector 能用select poll epoll
# select 採用輪詢,可以處理的對象的個數有限
# poll 採用輪詢,可以處理的對象的個數無限的
# epoll 回調
# TCP協議
# 監聽多個sk,conn對象,誰的數據先來,我就通知誰來處理
# 好處是什麼
 # 把很個等待變成一個等待,有一個代理替咱們來接收全部的請求

線程/進程/協程

 在正常的編程語言中
進程 是計算機中最小資源分配單位
數據隔離 開銷(開啓 銷燬 切換)大 內存級別數據安全 可是文件操做\數據庫操做數據不安全
manager : 數據共享
IPC(inter process communication):隊列\消息隊列memcache\rabbitmq\redis
管道 : 基於socket + pickle
原生的queue : 基於文件(管道 + 鎖)
第三方工具 : 基於網絡\穩定性更強
線程 計算機中能被CPU調度的最小單位
數據共享 開銷(開啓 銷燬 切換)小 數據不安全 數據共享程序可能會同時去操做一個變量
協程 本質是一條線程 協程任務對於操做系統來講不可見 協程是用戶級的單位
數據共享 開銷很是小(函數的調用的速度同樣快) 數據絕對安全
在Cpython解釋器下
進程
線程 不能利用多核 (flask django) : 文件操做更快
GIL鎖 : 全局解釋器鎖,鎖的是線程,保證了同一個進程中的多個線程之間只有一個線程能訪問CPU
限制了一個python進程中的多線程不能利用多核
沒法處理高計算型的任務
解決方案 開多進程
協程(tonado tiwsted sanic scrapy) : 全部的time.sleep socket 協程更快
一條線程
指的是程序可以在多個協程任務之間來回切換
若是在程序中遇到io就切換去執行另外一個程序,實現了使用協程來規避io,提升cpu的使用率

 yield協程

# def func():
#     yield 1
#     print(123)
#     yield 2
# def func2():
#     g = func()
#     g.__next__()
        # asyncio 基於yield關鍵字\gevent 基於greenlet來完成的
        # aiohttp