day18-網路程式設計（下）

1. OSI 7層模型

OSI的7層模型對於大家來說可能不太好理解，所以我們透過一個案例來講解：

假設，你在瀏覽器上輸入了一些關鍵字，內部透過DNS找到對應的IP後，再傳送資料時內部會做如下的事：

• 應用層：規定資料的格式。

  "GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n"
  

• 表示層：對應用層資料的編碼、壓縮（解壓縮）、分塊、加密（解密）等任務。

  "GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8')
  

• 會話層：負責與目標建立、中斷連線。

  在傳送資料之前，需要會先傳送 “連線” 的請求，與遠端建立連線後，再傳送資料。當然，傳送完畢之後，也涉及中斷連線的操作。
  

• 傳輸層：建立埠到埠的通訊，其實就確定雙方的埠資訊。

  資料："GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8')
  埠：
  	- 目標：80
  	- 本地：6784
  

• 網路層：標記目標IP資訊（IP協議層）

  資料："GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8')
  埠：
  	- 目標：80
  	- 本地：6784
  IP：
  	- 目標IP：110.242.68.3（百度）
  	- 本地IP：192.168.10.1
  

• 資料鏈路層：對資料進行分組並設定源和目標mac地址

  資料："POST /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8')
  埠：
  	- 目標：80
  	- 本地：6784
  IP：
  	- 目標IP：110.242.68.3（百度）
  	- 本地IP：192.168.10.1
  MAC：
  	- 目標MAC：FF-FF-FF-FF-FF-FF 
  	- 本機MAC：11-9d-d8-1a-dd-cd
  

• 物理層：將二進位制資料在物理媒體上傳輸。

  透過網線將二進位制資料傳送出去
  

每一層各司其職，最終保證資料呈現在到使用者手中。

簡單的可以理解為發快遞：將資料外面套了7個箱子，終端使用者收到箱子時需要開啟7個箱子才能拿到資料。而在運輸的過程中有些箱子是會被拆開並替換的，例如：

最終運送目標：上海 ~ 北京（中途可能需要中轉站），在中轉站會會開啟箱子檢視資訊，在進行轉發。
	- 對於二級中轉站（二層交換機）：拆開資料鏈路層的箱子，檢視mac地址資訊。
	- 對於三級中轉站（路由器或三層交換機）：拆開網路層的箱子，檢視IP資訊。

在開發過程中其實只能體現：應用層、表示層、會話層、傳輸層，其他層的處理都是在網路裝置中自動完成的。

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('110.242.68.3', 80)) # 向服務端傳送了資料包


key = "你好"
# 應用層
content = "GET /s?wd={} http1.1\r\nHost:www.baidu.com\r\n\r\n".format(key)
# 表示層
content = content.encode("utf-8")

client.sendall(content)
result = client.recv(8196)
print(result.decode('utf-8'))

# 會話層 & 傳輸層
client.close()

2. UDP和TCP協議

協議，其實就是規定 連線、收發資料的一些規定。

在OSI的 傳輸層 除了定義埠資訊以外，常見的還可以指定UDP或TCP的協議，協議不同連線和傳輸資料的細節也會不同。

• UDP（User Data Protocol）使用者資料包協議， 是⼀個⽆連線的簡單的⾯向資料包的傳輸層協議。 UDP不提供可靠性， 它只是把應⽤程式傳給IP層的資料包傳送出去， 但是並不能保證它們能到達⽬的地。 由於UDP在傳輸資料包前不⽤在客戶和伺服器之間建⽴⼀個連線， 且沒有超時重發等機制， 故⽽傳輸速度很快。

  常見的有：語音通話、視訊通話、實時遊戲畫面 等。
  

• TCP（Transmission Control Protocol，傳輸控制協議）是面向連線的協議，也就是說，在收發資料前，必須和對方建立可靠的連線，然後再進行收發資料。

  常見有：網站、手機APP資料獲取等。
  

2.1 UDP和TCP 示例程式碼

UDP示例如下：

• 服務端

  import socket
  
  server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  server.bind(('127.0.0.1', 8002))
  
  while True:
      data, (host, port) = server.recvfrom(1024) # 阻塞
      print(data, host, port)
      server.sendto("好的".encode('utf-8'), (host, port))
  

• 客戶端

  import socket
  
  client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  while True:
      text = input("請輸入要傳送的內容：")
      if text.upper() == 'Q':
          break
      client.sendto(text.encode('utf-8'), ('127.0.0.1', 8002))
      data, (host, port) = client.recvfrom(1024)
      print(data.decode('utf-8'))
  
  client.close()
  

TCP示例如下：

• 服務端

  import socket
  
  # 1.監聽本機的IP和埠
  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  sock.bind(('127.0.0.1', 8001))
  sock.listen(5)
  
  while True:
      # 2.等待，有人來連線（阻塞）
      conn, addr = sock.accept()
  
      # 3.等待，連線者傳送訊息（阻塞）
      client_data = conn.recv(1024)
      print(client_data)
  
      # 4.給連線者回復訊息
      conn.sendall(b"hello world")
  
      # 5.關閉連線
      conn.close()
  
  # 6.停止服務端程式
  sock.close()
  

• 客戶端

  import socket
  
  # 1. 向指定IP傳送連線請求
  client = socket.socket()
  client.connect(('127.0.0.1', 8001))
  
  # 2. 連線成功之後，傳送訊息
  client.sendall(b'hello')
  
  # 3. 等待，訊息的回覆（阻塞）
  reply = client.recv(1024)
  print(reply)
  
  # 4. 關閉連線
  client.close()
  

2.2 TCP三次握手和四次揮手

這是一個常見的面試題。

    0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |          Source Port          |       Destination Port        |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                        Sequence Number                        |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                    Acknowledgment Number                      |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |  Data |           |U|A|P|R|S|F|                               |
   | Offset| Reserved  |R|C|S|S|Y|I|            Window             |
   |       |           |G|K|H|T|N|N|                               |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |           Checksum            |         Urgent Pointer        |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                    Options                    |    Padding    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                             data                              |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

網路中的雙方想要基於TCP連線進行通訊，必須要經過：

• 建立連線，客戶端和服務端要進行三次握手。

  # 服務端
  import socket
  
  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  sock.bind(('127.0.0.1', 8001))
  sock.listen(5)
  
  while True:
      conn, addr = sock.accept() # 等待客戶端連線
      ...
  

  # 客戶端
  import socket
  client = socket.socket()
  client.connect(('127.0.0.1', 8001)) # 發起連線
  

        客戶端                                                服務端
  
    1.  SYN-SENT    --> <seq=100><CTL=SYN>               --> SYN-RECEIVED
  
    2.  ESTABLISHED <-- <seq=300><ack=101><CTL=SYN,ACK>  <-- SYN-RECEIVED
  
    3.  ESTABLISHED --> <seq=101><ack=301><CTL=ACK>       --> ESTABLISHED
  
        
  At this point, both the client and server have received an acknowledgment of the connection. The steps 1, 2 establish the connection parameter (sequence number) for one direction and it is acknowledged. The steps 2, 3 establish the connection parameter (sequence number) for the other direction and it is acknowledged. With these, a full-duplex communication is established.
  

• 傳輸資料

  在收發資料的過程中，只有有資料的傳送就會有應答（ack），如果沒有ack，那麼內部會嘗試重複傳送。
  

• 關閉連線，客戶端和服務端要進行4次揮手。

  import socket
  
  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  sock.bind(('127.0.0.1', 8001))
  sock.listen(5)
  while True:
      conn, addr = sock.accept()
  	...
      conn.close() # 關閉連線
  sock.close()
  

  import socket
  
  client = socket.socket()
  client.connect(('127.0.0.1', 8001))
  ...
  client.close() # 關閉連線
  

         TCP A                                                TCP B
  
    1.  FIN-WAIT-1  --> <seq=100><ack=300><CTL=FIN,ACK>  --> CLOSE-WAIT
  
    2.  FIN-WAIT-2  <-- <seq=300><ack=101><CTL=ACK>      <-- CLOSE-WAIT
  
    3.  TIME-WAIT   <-- <seq=300><ack=101><CTL=FIN,ACK>  <-- LAST-ACK
  
    4.  TIME-WAIT   --> <seq=101><ack=301><CTL=ACK>      --> CLOSED
  

3. 粘包

兩臺電腦在進行收發資料時，其實不是直接將資料傳輸給對方。

• 對於傳送者，執行 sendall/send 傳送訊息時，是將資料先傳送至自己網路卡的 寫緩衝區 ，再由緩衝區將資料傳送給到對方網路卡的讀緩衝區。
• 對於接受者，執行 recv 接收訊息時，是從自己網路卡的讀緩衝區獲取資料。

所以，如果傳送者連續快速的傳送了2條資訊，接收者在讀取時會認為這是1條資訊，即：2個資料包粘在了一起。例如：

# socket客戶端（傳送者）
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8001))

client.sendall('alex正在吃'.encode('utf-8'))
client.sendall('翔'.encode('utf-8'))

client.close()


# socket服務端（接收者）
import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 8001))
sock.listen(5)
conn, addr = sock.accept()

client_data = conn.recv(1024)
print(client_data.decode('utf-8'))

conn.close()
sock.close()

如何解決粘包的問題？

每次傳送的訊息時，都將訊息劃分為 頭部（固定位元組長度） 和 資料 兩部分。例如：頭部，用4個位元組表示後面資料的長度。

• 傳送資料，先傳送資料的長度，再傳送資料（或拼接起來再傳送）。
• 接收資料，先讀4個位元組就可以知道自己這個資料包中的資料長度，再根據長度讀取到資料。

對於頭部需要一個數字並固定為4個位元組，這個功能可以藉助python的struct包來實現：

import struct

# ########### 數值轉換為固定4個位元組，四個位元組的範圍 -2147483648 <= number <= 2147483647  ###########
v1 = struct.pack('i', 199)
print(v1)  # b'\xc7\x00\x00\x00'

for item in v1:
    print(item, bin(item))

# ########### 4個位元組轉換為數字 ###########
v2 = struct.unpack('i', v1) # v1= b'\xc7\x00\x00\x00'
print(v2) # (199,)

示例程式碼：

• 服務端

  import socket
  import struct
  
  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  sock.bind(('127.0.0.1', 8001))
  sock.listen(5)
  conn, addr = sock.accept()
  
  # 固定讀取4位元組
  header1 = conn.recv(4)
  data_length1 = struct.unpack('i', header1)[0] # 資料位元組長度 21
  has_recv_len = 0
  data1 = b""
  while True:
      length = data_length1 - has_recv_len
      if length > 1024:
          lth = 1024
      else:
          lth = length
      chunk = conn.recv(lth) # 可能一次收不完，自己可以計算長度再次使用recv收取，直到收完為止。 1024*8 = 8196
      data1 += chunk
      has_recv_len += len(chunk)
      if has_recv_len == data_length1:
          break
  print(data1.decode('utf-8'))
  
  # 固定讀取4位元組
  header2 = conn.recv(4)
  data_length2 = struct.unpack('i', header2)[0] # 資料位元組長度
  data2 = conn.recv(data_length2) # 長度
  print(data2.decode('utf-8'))
  
  conn.close()
  sock.close()
  

• 客戶端

  import socket
  import struct
  
  client = socket.socket()
  client.connect(('127.0.0.1', 8001))
  
  # 第一條資料
  data1 = 'alex正在吃'.encode('utf-8')
  
  header1 = struct.pack('i', len(data1))
  
  client.sendall(header1)
  client.sendall(data1)
  
  # 第二條資料
  data2 = '翔'.encode('utf-8')
  header2 = struct.pack('i', len(data2))
  client.sendall(header2)
  client.sendall(data2)
  
  client.close()
  

案例：訊息 & 檔案上傳

• 服務端

  import os
  import json
  import socket
  import struct
  
  
  def recv_data(conn, chunk_size=1024):
      # 獲取頭部資訊：資料長度
      has_read_size = 0
      bytes_list = []
      while has_read_size < 4:
          chunk = conn.recv(4 - has_read_size)
          has_read_size += len(chunk)
          bytes_list.append(chunk)
      header = b"".join(bytes_list)
      data_length = struct.unpack('i', header)[0]
  
      # 獲取資料
      data_list = []
      has_read_data_size = 0
      while has_read_data_size < data_length:
          size = chunk_size if (data_length - has_read_data_size) > chunk_size else data_length - has_read_data_size
          chunk = conn.recv(size)
          data_list.append(chunk)
          has_read_data_size += len(chunk)
  
      data = b"".join(data_list)
  
      return data
  
  
  def recv_file(conn, save_file_name, chunk_size=1024):
      save_file_path = os.path.join('files', save_file_name)
      # 獲取頭部資訊：資料長度
      has_read_size = 0
      bytes_list = []
      while has_read_size < 4:
          chunk = conn.recv(4 - has_read_size)
          bytes_list.append(chunk)
          has_read_size += len(chunk)
      header = b"".join(bytes_list)
      data_length = struct.unpack('i', header)[0]
  
      # 獲取資料
      file_object = open(save_file_path, mode='wb')
      has_read_data_size = 0
      while has_read_data_size < data_length:
          size = chunk_size if (data_length - has_read_data_size) > chunk_size else data_length - has_read_data_size
          chunk = conn.recv(size)
          file_object.write(chunk)
          file_object.flush()
          has_read_data_size += len(chunk)
      file_object.close()
  
  
  def run():
      sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      # IP可複用
      sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  
      sock.bind(('127.0.0.1', 8001))
      sock.listen(5)
      while True:
          conn, addr = sock.accept()
  
          while True:
              # 獲取訊息型別
              message_type = recv_data(conn).decode('utf-8')
              if message_type == 'close':  # 四次揮手，空內容。
                  print("關閉連線")
                  break
              # 檔案：{'msg_type':'file', 'file_name':"xxxx.xx" }
              # 訊息：{'msg_type':'msg'}
              message_type_info = json.loads(message_type)
              if message_type_info['msg_type'] == 'msg':
                  data = recv_data(conn)
                  print("接收到訊息：", data.decode('utf-8'))
              else:
                  file_name = message_type_info['file_name']
                  print("接收到檔案，要儲存到：", file_name)
                  recv_file(conn, file_name)
  
          conn.close()
      sock.close()
  
  
  if __name__ == '__main__':
      run()
  
  

• 客戶端

  import os
  import json
  import socket
  import struct
  
  
  def send_data(conn, content):
      data = content.encode('utf-8')
      header = struct.pack('i', len(data))
      conn.sendall(header)
      conn.sendall(data)
  
  
  def send_file(conn, file_path):
      file_size = os.stat(file_path).st_size
      header = struct.pack('i', file_size)
      conn.sendall(header)
  
      has_send_size = 0
      file_object = open(file_path, mode='rb')
      while has_send_size < file_size:
          chunk = file_object.read(2048)
          conn.sendall(chunk)
          has_send_size += len(chunk)
      file_object.close()
  
  
  def run():
      client = socket.socket()
      client.connect(('127.0.0.1', 8001))
  
      while True:
          """
          請傳送訊息，格式為：
              - 訊息：msg|你好呀
              - 檔案：file|xxxx.png
          """
          content = input(">>>")  # msg or file
          if content.upper() == 'Q':
              send_data(client, "close")
              break
          input_text_list = content.split('|')
          if len(input_text_list) != 2:
              print("格式錯誤，請重新輸入")
              continue
  
          message_type, info = input_text_list
  
          # 發訊息
          if message_type == 'msg':
  
              # 發訊息型別
              send_data(client, json.dumps({"msg_type": "msg"}))
  
              # 發內容
              send_data(client, info)
  
          # 發檔案
          else:
              file_name = info.rsplit(os.sep, maxsplit=1)[-1]
  
              # 發訊息型別
              send_data(client, json.dumps({"msg_type": "file", 'file_name': file_name}))
  
              # 發內容
              send_file(client, info)
  
      client.close()
  
  
  if __name__ == '__main__':
      run()
  
  

4. 阻塞和非阻塞

預設情況下我們編寫的網路程式設計的程式碼都是阻塞的（等待），阻塞主要體現在：

# ################### socket服務端（接收者）###################
import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 8001))
sock.listen(5)

# 阻塞
conn, addr = sock.accept()

# 阻塞
client_data = conn.recv(1024)
print(client_data.decode('utf-8'))

conn.close()
sock.close()


# ################### socket客戶端（傳送者） ###################
import socket

client = socket.socket()

# 阻塞
client.connect(('127.0.0.1', 8001))

client.sendall('alex正在吃翔'.encode('utf-8'))

client.close()

如果想要讓程式碼變為非阻塞，需要這樣寫：

# ################### socket服務端（接收者）###################
import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.setblocking(False) # 加上就變為了非阻塞

sock.bind(('127.0.0.1', 8001))
sock.listen(5)

# 非阻塞
conn, addr = sock.accept()

# 非阻塞
client_data = conn.recv(1024)
print(client_data.decode('utf-8'))

conn.close()
sock.close()

# ################### socket客戶端（傳送者） ###################
import socket

client = socket.socket()

client.setblocking(False) # 加上就變為了非阻塞

# 非阻塞
client.connect(('127.0.0.1', 8001))

client.sendall('alex正在吃翔'.encode('utf-8'))

client.close()

如果程式碼變成了非阻塞，程式執行時一旦遇到 accept、recv、connect 就會丟擲 BlockingIOError 的異常。

這不是程式碼編寫的有錯誤，而是原來的IO阻塞變為非阻塞之後，由於沒有接收到相關的IO請求丟擲的固定錯誤。

非阻塞的程式碼一般與IO多路複用結合，可以迸發出更大的作用。

5. IO多路複用

I/O多路複用指：透過一種機制，可以監視多個描述符，一旦某個描述符就緒（一般是讀就緒或者寫就緒），能夠通知程式進行相應的讀寫操作。

IO多路複用 + 非阻塞，可以實現讓TCP的服務端同時處理多個客戶端的請求，例如：

# ################### socket服務端 ###################
import select
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setblocking(False)  # 加上就變為了非阻塞
server.bind(('127.0.0.1', 8001))
server.listen(5)

inputs = [server, ] # socket物件列表 -> [server, 第一個客戶端連線conn ]

while True:
    # 當 引數1 序列中的socket物件發生可讀時（accetp和read），則獲取發生變化的物件並新增到 r列表中。
    # r = []
    # r = [server,]
    # r = [第一個客戶端連線conn,]
    # r = [server,]
    # r = [第一個客戶端連線conn，第二個客戶端連線conn]
    # r = [第二個客戶端連線conn,]
    r, w, e = select.select(inputs, [], [], 0.05)
    for sock in r:
        # server
        if sock == server:
            conn, addr = sock.accept() # 接收新連線。
            print("有新連線")
            # conn.sendall()
            # conn.recv("xx")
            inputs.append(conn)
        else:
            data = sock.recv(1024)
            if data:
                print("收到訊息：", data.decode("utf-8"))
            else:
                print("關閉連線")
                inputs.remove(sock)
	# 乾點其他事 20s
"""
優點：
	1. 乾點其他的事。
	2. 讓服務端支援多個客戶端同時來連線。
"""

# ################### socket客戶端 ###################
import socket

client = socket.socket()
# 阻塞
client.connect(('127.0.0.1', 8001))

while True:
    content = input(">>>")
    if content.upper() == 'Q':
        break
    client.sendall(content.encode('utf-8'))

client.close()

# ################### socket客戶端 ###################
import socket

client = socket.socket()
# 阻塞
client.connect(('127.0.0.1', 8001))


while True:
    content = input(">>>")
    if content.upper() == 'Q':
        break
    client.sendall(content.encode('utf-8'))

client.close() # 與服務端斷開連線（四次揮手），預設會向服務端傳送空資料。

IO多路複用 + 非阻塞，可以實現讓TCP的客戶端同時傳送多個請求，例如：去某個網站傳送下載圖片的請求。

import socket
import select
import uuid
import os

client_list = []  # socket物件列表

for i in range(5):
    client = socket.socket()
    client.setblocking(False)

    try:
        # 連線百度，雖然有異常BlockingIOError，但向還是正常傳送連線的請求
        client.connect(('47.98.134.86', 80))
    except BlockingIOError as e:
        pass

    client_list.append(client)

recv_list = []  # 放已連線成功，且已經把下載圖片的請求發過去的socket
while True:
    # w = [第一個socket物件,]
    # r = [socket物件,]
    r, w, e = select.select(recv_list, client_list, [], 0.1)
    for sock in w:
        # 連線成功，傳送資料
        # 下載圖片的請求
        sock.sendall(b"GET /nginx-logo.png HTTP/1.1\r\nHost:47.98.134.86\r\n\r\n")
        recv_list.append(sock)
        client_list.remove(sock)

    for sock in r:
        # 資料傳送成功後，接收的返回值（圖片）並寫入到本地檔案中
        data = sock.recv(8196)
        content = data.split(b'\r\n\r\n')[-1]
        random_file_name = "{}.png".format(str(uuid.uuid4()))
        with open(os.path.join("images", random_file_name), mode='wb') as f:
            f.write(content)
        recv_list.remove(sock)

    if not recv_list and not client_list:
        break
        
"""
優點：
	1. 可以偽造出併發的現象。
"""

基於 IO多路複用 + 非阻塞的特性，無論編寫socket的服務端和客戶端都可以提升效能。其中

• IO多路複用，監測socket物件是否有變化（是否連線成功？是否有資料到來等）。
• 非阻塞，socket的connect、recv過程不再等待。

注意：IO多路複用只能用來監聽 IO物件 是否發生變化，常見的有：檔案是否可讀寫、電腦終端裝置輸入和輸出、網路請求（常見）。

在Linux作業系統化中 IO多路複用 有三種模式，分別是：select，poll，epoll。（windows 只支援select模式）

監測socket物件是否新連線到來 or 新資料到來。

select
 
select最早於1983年出現在4.2BSD中，它透過一個select()系統呼叫來監視多個檔案描述符的陣列，當select()返回後，該陣列中就緒的檔案描述符便會被核心修改標誌位，使得程序可以獲得這些檔案描述符從而進行後續的讀寫操作。
select目前幾乎在所有的平臺上支援，其良好跨平臺支援也是它的一個優點，事實上從現在看來，這也是它所剩不多的優點之一。
select的一個缺點在於單個程序能夠監視的檔案描述符的數量存在最大限制，在Linux上一般為1024，不過可以透過修改宏定義甚至重新編譯核心的方式提升這一限制。
另外，select()所維護的儲存大量檔案描述符的資料結構，隨著檔案描述符數量的增大，其複製的開銷也線性增長。同時，由於網路響應時間的延遲使得大量TCP連線處於非活躍狀態，但呼叫select()會對所有socket進行一次線性掃描，所以這也浪費了一定的開銷。
 
poll
 
poll在1986年誕生於System V Release 3，它和select在本質上沒有多大差別，但是poll沒有最大檔案描述符數量的限制。
poll和select同樣存在一個缺點就是，包含大量檔案描述符的陣列被整體複製於使用者態和核心的地址空間之間，而不論這些檔案描述符是否就緒，它的開銷隨著檔案描述符數量的增加而線性增大。
另外，select()和poll()將就緒的檔案描述符告訴程序後，如果程序沒有對其進行IO操作，那麼下次呼叫select()和poll()的時候將再次報告這些檔案描述符，所以它們一般不會丟失就緒的訊息，這種方式稱為水平觸發（Level Triggered）。
 
epoll
 
直到Linux2.6才出現了由核心直接支援的實現方法，那就是epoll，它幾乎具備了之前所說的一切優點，被公認為Linux2.6下效能最好的多路I/O就緒通知方法。
epoll可以同時支援水平觸發和邊緣觸發（Edge Triggered，只告訴程序哪些檔案描述符剛剛變為就緒狀態，它只說一遍，如果我們沒有采取行動，那麼它將不會再次告知，這種方式稱為邊緣觸發），理論上邊緣觸發的效能要更高一些，但是程式碼實現相當複雜。
epoll同樣只告知那些就緒的檔案描述符，而且當我們呼叫epoll_wait()獲得就緒檔案描述符時，返回的不是實際的描述符，而是一個代表就緒描述符數量的值，你只需要去epoll指定的一個陣列中依次取得相應數量的檔案描述符即可，這裡也使用了記憶體對映（mmap）技術，這樣便徹底省掉了這些檔案描述符在系統呼叫時複製的開銷。
另一個本質的改進在於epoll採用基於事件的就緒通知方式。在select/poll中，程序只有在呼叫一定的方法後，核心才對所有監視的檔案描述符進行掃描，而epoll事先透過epoll_ctl()來註冊一個檔案描述符，一旦基於某個檔案描述符就緒時，核心會採用類似callback的回撥機制，迅速啟用這個檔案描述符，當程序呼叫epoll_wait()時便得到通知。

補充：socket + 非阻塞+ IO多路複用（IO操作物件都可以監測 + 檔案）。

總結

1. OSI 7層模型

   應用層、表示層、會話層、傳輸層、網路層、資料鏈路層、物理層。
   

2. UDP和TCP的區別

   UDP，速度快但無法保證資料的準確性。
   TCP，需要先建立可靠連線，在進行收發資料（ack）。
   

3. TCP的三次握手和四次揮手

4. 為什麼會有粘包？如何解決？

5. 如何讓socket請求變成非阻塞？

6. IO多路複用的作用？

   監測多個 IO物件 是否發生變化（可讀/可寫）。
   

   • IO多路複用 + 非阻塞 + socket服務端，可以讓服務端同時處理多個客戶端的請求。
   • IO多路複用 + 非阻塞 + socket客戶端，可以向服務端同時發起多個請求。

作業（模組大作業）

請基於TCP協議實現一個網盤系統，包含客戶端、服務端，各自需求如下：

• 客戶端

  • 使用者註冊，註冊成功之後，在服務端的指定目錄下為此使用者建立一個資料夾，該資料夾下以後儲存當前使用者的資料（類似於網盤）。

  • 使用者登入

  • 檢視網盤目錄下的所有檔案（一級即可），ls命令

  • 上傳檔案，如果網盤已存在則重新上傳（覆蓋）。

  • 下載檔案（進度條）

    先判斷要下載本地路徑中是否存在該檔案。
    - 不存在，直接下載
    - 存在，則讓使用者選擇是否續傳（繼續下載）。
    	- 續傳，在上次的基礎上繼續下載。
    	- 不續傳，從頭開始下載。
    

• 服務端

  • 支援註冊，併為使用者初始化相關目錄。

    註冊成功之後，將所有使用者資訊儲存到特定的Excel檔案中
    

    

  • 支援登入

  • 支援檢視當前使用者網盤目錄下的所有檔案。

  • 支援上傳

  • 支援下載

參考程式碼見：https://files.cnblogs.com/files/blogs/814578/網盤系統（參考程式碼）.zip?t=1713753389&download=true