IPC通信

# 网络编程核心概念全解析

从浏览器输入 URL 到服务器响应的完整流程

---

## 目录

1. [核心概念](#核心概念)
2. [完整流程演示](#完整流程演示)
3. [epoll 详解](#epoll-详解)
4. [并发模型](#并发模型)
5. [性能优化技术](#性能优化技术)

---

## 核心概念

### Socket 是什么？

**Socket = 操作系统提供的"网络通信接口"**

# 浏览器创建 Socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 5000))

# 内核处理：
# 1. 查路由表：127.0.0.1 是本机
# 2. TCP 三次握手（全在内存中）
# 3. 返回文件描述符 fd=3

# 浏览器构造请求
http_request = """GET /api/user HTTP/1.1\r
Host: localhost:5000\r
Connection: keep-alive\r
\r
"""

# 发送数据
sock.send(http_request.encode())

# Gunicorn 的 epoll 被唤醒
events = epoll.poll()  # [(4, EPOLLIN)]

# 读取数据
data = os.read(fd=4, size=4096)

# Flask 处理
@app.route("/api/user")
def get_user():
    return {"name": "张三", "age": 25}

# Flask 生成响应
response = """HTTP/1.1 200 OK\r
Content-Type: application/json\r
Content-Length: 27\r
\r
{"name":"张三","age":25}"""

# 发送回浏览器
sock.send(response.encode())

# 低效：逐个检查 10000 个连接
while True:
    for sock in all_sockets:  # 遍历 10000 次
        data = sock.recv(1024)  # 大部分时间阻塞
        if data:
            process(data)

import select

# 创建 epoll 对象
epoll = select.epoll()

# 注册所有关心的 Socket
for sock in all_sockets:
    epoll.register(sock.fileno(), select.EPOLLIN)

while True:
    # 内核通知："这些 Socket 有数据了"
    events = epoll.poll()  # 只返回就绪的 fd
    
    for fd, event in events:
        data = os.read(fd, 4096)  # 保证不阻塞
        process(data)

# 时刻 T1: 三个连接同时有数据
events = epoll.poll()  # [(5,IN), (6,IN), (7,IN)]

# 时刻 T2: 先处理 fd=5，耗时 10 秒
data5 = os.read(5, 4096)
time.sleep(10)  # 模拟慢处理

# fd=6 和 fd=7 的数据依然在内核缓冲区等着
# 不会丢失！

# 客户端连续发送
sock.send(b"消息1")
sock.send(b"消息2")
sock.send(b"消息3")

# 服务端接收
data = os.read(fd, 4096)
# 保证收到顺序：消息1 → 消息2 → 消息3
# 不会出现 消息3 先于 消息1 到达

events = epoll.poll()  # [(5,IN), (6,IN), (7,IN)]

for fd, event in events:
    data = os.read(fd, 4096)
    handle(data)  # 处理 1 秒
    
# 总耗时：3 秒

from concurrent.futures import ThreadPoolExecutor

pool = ThreadPoolExecutor(max_workers=4)

while True:
    events = epoll.poll()
    
    for fd, event in events:
        pool.submit(handle_connection, fd)

def handle_connection(fd):
    data = os.read(fd, 4096)
    handle(data)  # 各自独立执行
    
# 总耗时：1 秒（并发处理）

# gunicorn.conf.py
workers = 3       # 3 个进程
threads = 4       # 每个进程 4 个线程
worker_class = "gthread"

# 并发能力：3 × 4 = 12 个请求同时处理

processing_fds = set()
lock = threading.Lock()

while True:
    events = epoll.poll()
    
    for fd, event in events:
        with lock:
            if fd in processing_fds:
                continue  # 正在处理，跳过
            processing_fds.add(fd)
        
        pool.submit(handle_and_cleanup, fd)

def handle_and_cleanup(fd):
    try:
        data = os.read(fd, 4096)
        process(data)
    finally:
        with lock:
            processing_fds.remove(fd)

import os

# 使用 sendfile 系统调用
os.sendfile(
    sock.fileno(),    # 目标 Socket
    file_fd,          # 源文件
    offset=0,
    count=file_size
)

# 数据流：磁盘 → 内核 → 网卡
# 完全不经过用户态！

# gunicorn.conf.py
keepalive = 10  # 连接空闲 10 秒后再关闭

import requests

# requests 内部维护连接池
# 多次请求同一服务器时自动复用连接
session = requests.Session()

for i in range(100):
    resp = session.get("http://api.example.com/data")
    # 底层复用同一个 TCP 连接

# 创建 Socket
fd = socket.socket(AF_INET, SOCK_STREAM)

# 连接
socket.connect(('127.0.0.1', 5000))

# 发送数据
socket.send(data)

# 接收数据
data = socket.recv(4096)

# epoll 操作
epoll = select.epoll()
epoll.register(fd, select.EPOLLIN)
events = epoll.poll()

# 零拷贝
os.sendfile(out_fd, in_fd, offset, count)