day40

目錄

• 軟件開發架構:

軟件開發架構:

C/S:
    Client: 客戶端
    Server: 服務端

    優勢:
        佔用網絡資源少,軟件的使用穩定

    缺點:
        服務端更新後,客戶端也得跟着跟新.
        須要使用多個軟件,須要下載多個客戶端

B/S:
    Browser: 瀏覽器(客戶端)
    Server: 服務端

服務端與客戶端做用:
    服務端: 24小時不間斷提供服務
    客戶端: 須要體驗服務端時,再去鏈接服務端,並享受服務

一 網絡編程:
1.互聯網協議OSI七層協議
1)應用層
2)表示層
3)會話層
4)傳輸層
5)網絡層
6)數據鏈路層
7)物理鏈接層

- 物理鏈接層
        基於電信號發送二進制數據.

    - 數據鏈路層
        1) 規定好電信號的分組方式
        2) 必需要有一塊網卡:
            - mac地址:
                12位惟一的16進制字符串
                    - 前6位: 廠商號
                    - 後6位: 流水號
        - 以太網協議:
            在同一個局域網內通訊.
            - 單播
                1對1吼
            - 廣播
                多對多吼
                - 廣播風暴:
                - 不能跨局域網通訊

    - 網絡層
        - ip: 定位局域網的位置
        - port: 惟一標識一臺計算機上一個應用程序.
        - arp協議:
            將mac地址獲取,並解析成ip和port.

    - 傳輸層
        - TCP
            特色:
                TCP協議稱之爲流式協議.

            若想要通訊,必須創建鏈接,並創建雙向通道.
            - 三次握手,四次揮手
                - 三次握手建鏈接
                    - 客戶端往服務端發送請求創建通道
                    - 服務端要確認客戶端的請求,並往客戶端也發送請求創建通道
                    - 客戶端接收到服務端創建鏈接的請求,並返回確認
                    - 創建雙向通道

                - 雙向通道:
                    - 反饋機制
                    客戶端往服務端發送請求獲取數據,服務端務必返回數據,客戶端確認收到.
                    反則會反覆發送,一直到某個時間段內,會中止發送

                - 四次揮手斷鏈接
                    - C往S發送斷開鏈接請求,S返回確認收到
                    - S須要再次發送斷開鏈接請求
                    - C返回確認收到
                    - 最終確認斷開鏈接

        - UDP
            1)數據不安全
            2)不須要創建雙向通道
            3)傳輸速度快
            4)不會有粘包問題
            5)客戶端發送數據,不須要服務端確認收到,愛收不收

        TCP與UPD的區別:
            TCP: 比喻成在打電話
            UDP: 比喻成發送短信

    - 應用層
        - ftp
        - http:
            能夠攜帶一堆數據

        - http + ssl

2.socket
    socket用來寫套接字客戶端與服務端的模塊,內部幫咱們封裝好了7層協議須要作的事情.

3.手擼socket套接字模板
    - 服務端:
        import socket
        server = socket.socket()
        server.bind(
            (ip, port)
        )  # 綁定手機號
        server.listen(6)  # 半鏈接池: 能夠接待7個客戶端
        # 監聽鏈接
        conn, addr =server.accept()
        # 接收消息
        data = conn.recv(1024)
        # 發送消息
        conn.send('消息內容'.encode('utf-8'))

    - 客戶端:
        import socket
        client = socket.socket()
        client.connect(
            (ip, port)
        )
        # 發送消息
        client.send()
        # 接收消息
        client.recv(1024)

4.subprocess(瞭解)
    用來經過代碼往cmd建立一個管道,而且發送命令和接收cmd返回的結果.
    import subprocess
    obj = subprocess.Popen(
        'cmd命令',
        shell=True,
        # 接收正確結果
        stdout=subprocess.PIPE,
        # 接收錯誤結果
        stderr=subprocess.PIPE
    )
    success = obj.stdout.read()
    error = obj.stderr.read()
    msg = success + error


5.黏包問題
    1.不能肯定對方發送數據的大小
    2.在短期內,間隔時間短,而且數據量小的狀況, 默認將這些數據打包成一個
        屢次發送的數據 ---> 一次性發送

6.struct解決黏包問題
    初級版:
    i: 4
    能夠將一個數據的長度打包成一個固定長度的報頭.
    struct.pack('模式i', '源數據長度')
    data = 'gagawagwaga'
    # 打包成報頭
    headers = struct.pack('i', len(data))

    # 解包獲取數據真實長度
    data = struct.unpack('i', headers)[0]

    注意: 以什麼方式打包,必須以什麼方式解包.

    升級版:
        先將數據存放到字典中,將字典打包發送過去
        - 字典的好處:
            - 真實數據長度
            - 文件的描述信息
            - 發送的數據,更小

            dic = {
                'data_len': 1000000000000000000000046546544444444444444444444444444444444444444,
                文件的描述信息
            }

7.上傳大文件數據
    # 客戶端
    dic = {
            文件大小,
            文件名
           }

    with open(文件名, 'rb') as f:
        for line in f:
            client.send(line)


    # 服務端
    dic = {
            文件大小,
            文件名
           }
    init_recv = 0
    with open(文件名, 'wb') as f:
        while init_recv < 文件大小:
            data = conn.recv(1024)
            f.write(data)
            init_recv += len(data)


10.socketserver(現階段,瞭解)
    - 能夠支持併發
    import socketserver
    # 定義類
    # TCP: 必須繼承BaseRequestHandler類
    class MyTcpServer(socketserver.BaseRequestHandler):

        - handle
            # 內部實現了
            server = socket.socket()
            server.bind(
                ('127.0.0.1', 9527)
            )
            server.listen(5)  ---

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

        # 必須重寫父類的handle, 當客戶端鏈接時會調用該方法
        def handle(self):
            print(self.client_address)
            while True:
                try:
                    # 1.接收消息
                    # request.recv(1024) == conn.recv(1024)
                    data = self.request.recv(1024).decode('utf-8')
                    send_msg = data.upper()
                    self.request.send(send_msg.encode('utf-8'))

                except Exception as e:
                    print(e)
                    break
    TCP:
        SOCK_STREAM
        conn.recv()

    UDP模板:
        SOCK_DGRAM
        server.recvfrom()

        - 服務端
            import socket
            server = socket.socket(
                type=socket.SOCK_DGRAM
            )
            server.bind(
                (ip, port)
            )
            data, addr = server.recvfrom(1024)
            server.sendto(data, addr)

        - 客戶端
            import socket
            client = socket.socket(
                type=socket.SOCK_DGRAM
            )
            ip_port = (ip, port)

            client.sendto(data, ip_port)

            data, _ = client.recvfrom(1024)
            print(data)

二 併發編程
12.多道技術
- 單道

- 多道: 切換 + 保存狀態
        - 空間上的複用
            支持多個程序使用

        - 時間上的複用
            - 遇到IO操做就會切換程序
            - 程序佔用CPU時間過長切換

13.併發與並行
    併發: 看起來像同時運行: 多道技術
    並行: 真正意義上的同時運行: 多核下


14.進程
    進程是資源單位,沒建立一個進程都會生成一個名稱空間,佔用內存資源.

    - 程序與進程
          程序就是一堆代碼
          進程就是一堆代碼運行的過程

  - 進程調度
        - 時間片輪轉法
            10個進程, 將固定時間,等分紅10份時間片,分配給每個進程.

        - 分級反饋隊列
            1級別:
            2級別:
            3級別:


  - 進程的三個狀態
        - 就緒態:
            建立多個進程, 必需要排隊準備運行

        - 運行態:
            進程開始運行, 1.結束  2.阻塞

        - 阻塞態:
            當運行態遇到IO操做,就會進阻塞態.

  - 同步與異步
        提交任務的方式
        - 同步: 同步提交, 串行,一個任務結束後,另外一個任務才能提交併執行.
        - 異步: 異步提交, 多個任務能夠併發運行

  - 阻塞與非阻塞
    - 阻塞:
        阻塞態
    - 非阻塞:
        就緒態
        運行態

  - 同步和異步、阻塞和非阻塞的區別。
        二者是不一樣的概念,不能混爲一談.

  - 建立進程的兩種方式
        一:
            p = Process(target=任務, args=(任務的參數, ))
            p.daemon = True  # 必須放在start()前,不然報錯
            p.start()  # 向操做系統提交建立進程的任務
            p.join()  # 向操做系統發送請求, 等全部子進程結束,父進程再結束

        二:
            class MyProcess(Process):
                def run(self):  # self == p
                    任務的過程

            p = MyProcess()
            p.daemon = True  # 必須放在start()前,不然報錯
            p.start()  # 向操做系統提交建立進程的任務
            p.join()  # 向操做系統發送請求, 等全部子進程結束,父進程再結束


  - 回收進程資源的兩種條件
        - 調用join讓子結束後,主進程才能結束.
        - 主進程正常結束

15.殭屍進程與孤兒進程(瞭解)
    殭屍進程: 凡是子進程結束後,PID號還在, 主進程意外死亡,無法給子進程回收資源.
        - 每一個子進程結束後,都會變成,殭屍進程 (PID)

    孤兒進程: 凡是子進程沒有結束,可是主進程意外死亡.操做系統優化機制(孤兒院),
    會將沒有主,而且存活的進程,在該進程結束後回收資源.

16.守護進程
    只要父進程結束,全部的子進程都必須結束.

17.互斥鎖
    將併發變成串行,犧牲執行效率,保證數據安全.

    from multiprocessing import Lock
    mutex = Lock()
    # 加鎖
    mutex.acquire()
    修改數據
    mutex.release()

18.隊列
    - FIFO隊列: 先進先出
    from multiprocessing import Queue
    q = Queue(5)
    # 添加數據,若隊列添加數據滿了,則等待
    q.put()
    # 添加數據,若隊列添加數據滿了,直接報錯
    q.put_nowait()

    # 獲取隊列中的數據
    q.get()  # 若隊列中沒數據,會卡住等待
    q.get_nowait()  # 若隊列中沒數據,會直接報錯

19.堆棧
    LIFO

20.IPC進程間通訊
    - 進程間的數據是隔離的
    - 隊列可讓進程間通訊
    - 把一個程序放入隊列中,另外一個程序從隊列中獲取,實現進程間數據交互


21.生產者與消費者 模型
    生產者: 生產數據
    消費者: 使用數據
    爲了保證 供需平衡.

    經過隊列實現, 生產者將數據扔進隊列中,消費者從隊列中獲取數據.
        能夠保證一邊生產一邊消費.



22.線程
    - 什麼是線程
        - 進程: 資源單位
        - 線程: 執行單位
            - 建立進程時,會自帶一個線程

        一個進程下能夠建立多個線程.

    - 使用線程的好處
        節省資源的開銷

    - 進程與線程優缺點:
        - 進程:
            優勢:
                - 多核下能夠並行執行
                - 計算密集型下提升效率

            缺點:
                - 開銷資源遠高於線程

        - 線程:
            優勢:
                - 佔用資源遠比進程小
                - IO密集型下提升效率

            缺點:
                - 沒法利用多核優點


23.線程間數據是共享的
    - 畫圖

24.GIL全局解釋器鎖

    - 只有Cpython纔有自帶一個GIL全局解釋器鎖
    1.GIL本質上是一個互斥鎖.
    2.GIL的爲了阻止同一個進程內多個線程同時執行(並行)
        - 單個進程下的多個線程沒法實現並行,但能實現併發

    3.這把鎖主要是由於CPython的內存管理不是 "線程安全" 的.
        - 內存管理
            - 垃圾回收機制

            注意: 多個線程過來執行,一旦遇到IO操做,就會立馬釋放GIL解釋器鎖,交給下一個先進來的線程.

    總結: GIL的存在就是爲了保證線程安全的,保證數據安全

25.多線程使用的好處
    - 多線程:
        IO密集型,提升效率

    - 多進程
        計算密集型,提升效率

26.死鎖現象(瞭解)

27.遞歸鎖(瞭解,之後不用)
    解決死鎖現象
    mutex = Lock()  # 只能引用1次
    mutex1, mutex2 = RLock()  # 能夠引用屢次
    +1, 只要這把鎖計數爲0釋放該鎖, 讓下一我的使用, 就不會出現死鎖現象.

28.信號量(絕對了解)
    信號量也是一把鎖, 可讓多個任務一塊兒使用.
    互斥鎖:
        只能讓一個任務使用
    信號量:
        可讓多個任務一塊兒使用.
        sm = Semaphore(5)  可讓5個任務使用

29.線程隊列
    使用場景:
        若線程間數據不安全狀況下使用線程隊列, 爲了保證線程間數據的安全.
    import queue
    - FIFO: 先進先出隊列
        queue.Queue()
    - LIFO: 後進先出隊列
        queue.LifoQueue()
    - 優先級隊列:
        - 根據數字大小判斷,判斷出隊優先級.
        - 進隊數據是無序的
        queue.PriorityQueue()

30.event事件
    能夠控制線程的執行,讓一些線程控制另外一些線程的執行.
    e = Event()

    - 線程1
    e.set()  # 給線程2發送信號,讓他執行

    - 線程2
    e.wait()  # 等待線程1的信號

31.進程池與線程池
    爲了控制進程/線程建立的數量,保證了硬件能正常運行.
    from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor

    pool1 = ProcessPoolExecutor()  # 默認CPU個數
    pool2 = ThreadPoolExecutor()  # CPU個數 * 5
    pool3 = ProcessPoolExecutor(100)  # 100個
    pool4 = ThreadPoolExecutor(200)  # 200個

    # 將函數地址的執行結果,給回調函數
    pool4.submit(函數地址, 參數).add_done_callback(回調函數地址)

    - 回調函數(必須接收一個參數res):
        # 獲取值
        res2 = res.result()

32.協程
    - 進程: 資源單位
    - 線程: 執行單位
    - 協程: 單線程下實現併發, 不是任何的單位,是程序員YY出來的名字.

    - 單線程下實現併發
        好處是節省資源, 單線程 < 多線程 < 多進程

        - IO密集型下:
            協程有優點

        - 計算密集型下:
            進程有優點

    - 高併發:
        - 多進程 + 多線程 + 協程   (Nginx)

    協程的建立:
        手動實現切換 + 保存狀態:
            - yield

            - 函數一直在調用next()
                會不停地切換

            yield不能監聽IO操做的任務
            - gevent來實現監聽IO操做

33.gevent
    pip3 install gevent
    from gevent import monkey
    monkey.patch_all()  # 設置監聽全部IO
    from gevent import spawn, joinall  # 實現 切換 + 保存狀態

    - 實現了單線程下實現併發
    s1 = spawn(任務1)
    s2 = spawn(任務2)
    joinall([s1, s2])

34.IO模型(瞭解)
    - 阻塞IO
    - 非阻塞IO
    - 多路複用IO
    - 異步IO