并发服务器的实现

封面图 • 2025-11-06 • 嵌入式

并发服务器的实现是指在服务器端同时处理多个客户端请求的能力。这种能力可以通过多种方式实现，常见的有：

---

## 一、并发服务器的实现方式

### 1. **多进程（Multiprocessing）**
- 每个客户端连接由一个独立的子进程处理。
- 优点：简单易实现，互不干扰。
- 缺点：进程创建和销毁开销大，资源消耗高。

#### 示例代码（Python）：
```python
import socket
import os

def handle_client(client_socket):
    client_socket.send(b"Hello from server!\n")
    client_socket.close()

def main():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(("0.0.0.0", 8080))
    server.listen(5)
    print("Server is listening...")

while True:
        client, addr = server.accept()
        print(f"Connected by {addr}")
        pid = os.fork()
        if pid == 0:
            # 子进程处理客户端
            handle_client(client)
            os._exit(0)
        else:
            # 父进程关闭客户端套接字
            client.close()

if __name__ == "__main__":
    main()
```

---

### 2. **多线程（Multithreading）**
- 每个客户端连接由一个独立的线程处理。
- 优点：比进程轻量，适合 I/O 密集型任务。
- 缺点：受 GIL（全局解释器锁）限制（在 Python 中）。

#### 示例代码（Python）：
```python
import socket
import threading

def handle_client(client_socket):
    client_socket.send(b"Hello from server!\n")
    client_socket.close()

def main():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(("0.0.0.0", 8080))
    server.listen(5)
    print("Server is listening...")

while True:
        client, addr = server.accept()
        print(f"Connected by {addr}")
        thread = threading.Thread(target=handle_client, args=(client,))
        thread.start()

if __name__ == "__main__":
    main()
```

---

### 3. **异步 I/O（Asynchronous I/O）**
- 使用事件循环（如 `asyncio`）来处理多个连接。
- 优点：高效、可扩展性好，适合高并发场景。
- 缺点：编程复杂度较高。

#### 示例代码（Python with asyncio）：
```python
import asyncio

async def handle_client(reader, writer):
    writer.write(b"Hello from server!\n")
    await writer.drain()
    writer.close()

async def main():
    server = await asyncio.start_server(handle_client, '0.0.0.0', 8080)
    print("Server is listening...")
    async with server:
        await server.serve_forever()

asyncio.run(main())
```

---

### 4. **I/O 多路复用（Select/Poll/Epoll）**
- 使用 `select`, `poll`, 或 `epoll` 来监控多个文件描述符的状态。
- 适用于 C/C++ 等语言中高性能服务器的实现。

#### 示例代码（C语言，使用 select）：
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    fd_set readfds;

// 创建 socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

// 绑定地址
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);

if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

if (listen(server_fd, 10) < 0) {
        perror("listen");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

printf("Server is listening on port 8080...\n");

while (1) {
        FD_ZERO(&readfds);
        FD_SET(server_fd, &readfds);

// 监听所有连接
        if (select(server_fd + 1, &readfds, NULL, NULL, NULL) < 0) {
            perror("select error");
            continue;
        }

if (FD_ISSET(server_fd, &readfds)) {
            if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
                perror("accept");
                continue;
            }

char buffer[1024] = {0};
            read(new_socket, buffer, 1024);
            printf("Message: %s\n", buffer);

const char *response = "Hello from server!";
            write(new_socket, response, strlen(response));
            close(new_socket);
        }
    }

return 0;
}
```

---

## 二、选择哪种方式？

| 方式         | 适用场景                     | 优点                         | 缺点                         |
|--------------|------------------------------|------------------------------|------------------------------|
| 多进程       | 小规模、CPU 密集型任务       | 简单，隔离性强               | 进程切换开销大               |
| 多线程       | 中等规模、I/O 密集型任务     | 轻量，共享内存               | 受 GIL 限制（Python）        |
| 异步 I/O     | 高并发、I/O 密集型任务       | 高性能，低延迟               | 编程复杂                     |
| I/O 多路复用 | 高性能服务器（C/C++）       | 高效，支持大量连接           | 需要手动管理状态             |

---

## 三、总结

并发服务器的核心是**同时处理多个客户端请求**。根据应用场景、语言、性能需求等，可以选择不同的实现方式。在现代 Web 开发中，**异步 I/O**（如 `Node.js`, `Go`, `Python asyncio`）是主流选择；而在系统级开发中，**I/O 多路复用** 是常用方案。

如果你有具体的语言或平台（如 Java、C++、Go 等），我可以提供更针对性的实现示例。