当前位置： 首页 > news >正文

Linux环境下多进程Socket通信实现

news 来源：原创 2025/6/7 3:00:10

在网络编程中，服务器与多个客户端之间的通信是一个常见的需求。本文将介绍如何在Linux环境下实现一个服务器程序，该程序能够启动多个客户端进程，并通过Socket与这些客户端进行通信。

需求分析

我们的目标是实现以下功能：

  1. 服务器能够启动多个客户端进程，客户端数量可配置
  2. 每个客户端在不同的端口上监听
  3. 服务器能够连接到所有客户端
  4. 服务器能够同时向所有客户端发送消息
  5. 客户端接收到消息后发送确认
  6. 程序能够优雅地处理终止信号

系统架构

整个系统由两个主要组件组成：

  1. 客户端程序（Client）：

    • 在指定端口上监听连接
    • 接收服务器发送的消息
    • 发送确认消息给服务器

  2. 服务器程序（Server）：

    • 从配置文件读取设置
    • 启动多个客户端进程
    • 连接到每个客户端
    • 向所有客户端发送消息
    • 接收客户端的确认消息

实现细节

客户端实现（client.cpp）

客户端程序需要创建一个Socket，在指定端口上监听连接，接收服务器发送的消息，并发送确认。

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>#define BUFFER_SIZE 1024
#define DEFAULT_PORT 8888bool running = true;void signalHandler(int signum) {std::cout << "Interrupt signal (" << signum << ") received.\n";running = false;
}int main(int argc, char* argv[]) {// 注册信号处理函数，用于优雅关闭signal(SIGINT, signalHandler);signal(SIGTERM, signalHandler);// 解析命令行参数int port = DEFAULT_PORT;if (argc > 1) {port = std::stoi(argv[1]);}// 客户端ID（进程ID）pid_t pid = getpid();std::cout << "Client started with PID: " << pid << std::endl;// 创建Socketint clientSocket = socket(AF_INET, SOCK_STREAM, 0);if (clientSocket < 0) {std::cerr << "Error creating socket" << std::endl;return 1;}// 设置服务器地址struct sockaddr_in serverAddr;memset(&serverAddr, 0, sizeof(serverAddr));serverAddr.sin_family = AF_INET;serverAddr.sin_port = htons(port);serverAddr.sin_addr.s_addr = INADDR_ANY;// 绑定Socket到地址if (bind(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {std::cerr << "Error binding socket to port " << port << std::endl;close(clientSocket);return 1;}// 监听连接if (listen(clientSocket, 5) < 0) {std::cerr << "Error listening on socket" << std::endl;close(clientSocket);return 1;}std::cout << "Client listening on port " << port << std::endl;// 接受服务器连接struct sockaddr_in serverConnAddr;socklen_t serverLen = sizeof(serverConnAddr);int serverConnection = accept(clientSocket, (struct sockaddr*)&serverConnAddr, &serverLen);if (serverConnection < 0) {std::cerr << "Error accepting connection" << std::endl;close(clientSocket);return 1;}std::cout << "Connected to server at " << inet_ntoa(serverConnAddr.sin_addr) << ":" << ntohs(serverConnAddr.sin_port) << std::endl;// 接收服务器消息char buffer[BUFFER_SIZE];while (running) {memset(buffer, 0, BUFFER_SIZE);int bytesReceived = recv(serverConnection, buffer, BUFFER_SIZE - 1, 0);if (bytesReceived > 0) {std::cout << "Message received: " << buffer << std::endl;// 发送确认std::string ack = "Client " + std::to_string(pid) + " received message";send(serverConnection, ack.c_str(), ack.length(), 0);} else if (bytesReceived == 0) {std::cout << "Server disconnected" << std::endl;break;}else {if (errno != EINTR) { // 忽略信号中断std::cerr << "Error receiving data: " << strerror(errno) << std::endl;break;}}}// 清理资源close(serverConnection);close(clientSocket);std::cout << "Client terminated" << std::endl;return 0;
}

服务器实现（server.cpp）

服务器程序需要启动多个客户端进程，连接到每个客户端，并向所有客户端发送消息。

#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <thread>
#include <chrono>
#include <fstream>
#include <sstream>
#include <signal.h>
#include <sys/wait.h>
#include <mutex>
#include <condition_variable>#define BUFFER_SIZE 1024
#define DEFAULT_BASE_PORT 8888
#define DEFAULT_NUM_CLIENTS 3
#define CONFIG_FILE "server_config.txt"std::mutex mtx;
std::condition_variable cv;
bool allClientsConnected = false;
int connectedClients = 0;
int totalClients = 0;
std::vector<pid_t> clientPids;
std::vector<int> clientSockets;// 从配置文件读取配置
bool readConfig(int& numClients, int& basePort) {std::ifstream configFile(CONFIG_FILE);if (!configFile.is_open()) {std::cout << "Config file not found, using defaults" << std::endl;return false;}std::string line;while (std::getline(configFile, line)) {std::istringstream iss(line);std::string key;if (std::getline(iss, key, '=')) {std::string value;if (std::getline(iss, value)) {if (key == "NUM_CLIENTS") {numClients = std::stoi(value);} else if (key == "BASE_PORT") {basePort = std::stoi(value);}}}}configFile.close();return true;
}// 写入默认配置到文件
void writeDefaultConfig() {std::ofstream configFile(CONFIG_FILE);if (configFile.is_open()) {configFile << "NUM_CLIENTS=" << DEFAULT_NUM_CLIENTS << std::endl;configFile << "BASE_PORT=" << DEFAULT_BASE_PORT << std::endl;configFile.close();std::cout << "Created default configuration file" << std::endl;} else {std::cerr << "Unable to create configuration file" << std::endl;}
}// 启动客户端进程
pid_t launchClient(int port) {pid_t pid = fork();if (pid == 0) {// 子进程std::string portStr = std::to_string(port);execl("./Client", "Client", portStr.c_str(), nullptr);// 如果execl返回，说明出错了std::cerr << "Error launching client: " << strerror(errno) << std::endl;exit(1);} else if (pid < 0) {// fork失败std::cerr << "Fork failed: " << strerror(errno) << std::endl;return -1;}// 父进程return pid;
}// 连接到客户端
bool connectToClient(int& clientSocket, int port) {clientSocket = socket(AF_INET, SOCK_STREAM, 0);if (clientSocket < 0) {std::cerr << "Error creating socket for client on port " << port << std::endl;return false;}struct sockaddr_in clientAddr;memset(&clientAddr, 0, sizeof(clientAddr));clientAddr.sin_family = AF_INET;clientAddr.sin_port = htons(port);clientAddr.sin_addr.s_addr = inet_addr("127.0.0.1");// 尝试连接，带重试int retries = 10;while (retries > 0) {if (connect(clientSocket, (struct sockaddr*)&clientAddr, sizeof(clientAddr)) == 0) {std::cout << "Connected to client on port " << port << std::endl;return true;}std::cout << "Connection attempt failed, retrying in 1 second..." << std::endl;std::this_thread::sleep_for(std::chrono::seconds(1));retries--;}std::cerr << "Failed to connect to client on port " << port << std::endl;close(clientSocket);return false;
}// 连接客户端的线程函数
void clientConnectionThread(int port, int clientIndex) {int clientSocket;if (connectToClient(clientSocket, port)) {std::lock_guard<std::mutex> lock(mtx);clientSockets[clientIndex] = clientSocket;connectedClients++;if (connectedClients == totalClients) {allClientsConnected = true;cv.notify_one();}}
}// 向所有已连接的客户端发送消息
void sendToAllClients(const std::string& message) {for (int socket : clientSockets) {if (socket > 0) {send(socket, message.c_str(), message.length(), 0);// 接收确认char buffer[BUFFER_SIZE];memset(buffer, 0, BUFFER_SIZE);int bytesReceived = recv(socket, buffer, BUFFER_SIZE - 1, 0);if (bytesReceived > 0) {std::cout << "Acknowledgment: " << buffer << std::endl;}}}
}// 清理资源
void cleanup() {// 关闭所有客户端Socketfor (int socket : clientSockets) {if (socket > 0) {close(socket);}}// 终止所有客户端进程for (pid_t pid : clientPids) {if (pid > 0) {kill(pid, SIGTERM);waitpid(pid, nullptr, 0);}}
}// 信号处理函数
void signalHandler(int signum) {std::cout << "Interrupt signal (" << signum << ") received.\n";cleanup();exit(signum);
}int main() {// 注册信号处理函数signal(SIGINT, signalHandler);signal(SIGTERM, signalHandler);// 读取配置int numClients = DEFAULT_NUM_CLIENTS;int basePort = DEFAULT_BASE_PORT;if (!readConfig(numClients, basePort)) {writeDefaultConfig();}std::cout << "Starting server with " << numClients << " clients, base port: " << basePort << std::endl;// 初始化客户端向量totalClients = numClients;clientPids.resize(numClients, -1);clientSockets.resize(numClients, -1);// 启动客户端进程for (int i = 0; i < numClients; i++) {int port = basePort + i;pid_t pid = launchClient(port);if (pid > 0) {clientPids[i] = pid;std::cout << "Launched client " << i + 1 << " with PID " << pid << " on port " << port << std::endl;} else {std::cerr << "Failed to launch client " << i + 1 << std::endl;}}// 给客户端启动的时间std::cout << "Waiting for clients to start..." << std::endl;std::this_thread::sleep_for(std::chrono::seconds(2));// 连接到客户端std::vector<std::thread> connectionThreads;for (int i = 0; i < numClients; i++) {if (clientPids[i] > 0) {int port = basePort + i;connectionThreads.push_back(std::thread(clientConnectionThread, port, i));}}// 等待所有连接建立{std::unique_lock<std::mutex> lock(mtx);if (!allClientsConnected) {std::cout << "Waiting for all clients to connect..." << std::endl;cv.wait(lock, []{ return allClientsConnected; });}}// 等待所有连接线程结束for (auto& thread : connectionThreads) {thread.join();}std::cout << "All clients connected. Ready to send messages." << std::endl;// 主循环std::string message;while (true) {std::cout << "Enter message to send to all clients (or 'exit' to quit): ";std::getline(std::cin, message);if (message == "exit") {break;}std::cout << "Sending message to all clients..." << std::endl;sendToAllClients(message);}// 清理cleanup();std::cout << "Server terminated" << std::endl;return 0;
}

编译和运行

为了方便编译，我们可以创建一个Makefile：

CC = g++
CFLAGS = -std=c++11 -Wall -pthread
LDFLAGS = -pthreadall: Client ServerClient: client.cpp$(CC) $(CFLAGS) -o Client client.cpp $(LDFLAGS)Server: server.cpp$(CC) $(CFLAGS) -o Server server.cpp $(LDFLAGS)clean:rm -f Client Server server_config.txt.PHONY: all clean

编译和运行的步骤：

# 编译
make# 运行服务器
./Server

代码解析

端口号传递机制

服务器如何将端口号传递给客户端是本系统的一个关键点。整个过程如下：

  1. 服务器为每个客户端分配一个唯一的端口号（基础端口号 + 索引）
  2. 服务器通过fork()创建子进程
  3. 子进程通过execl()执行客户端程序，将端口号作为命令行参数传递
  4. 客户端程序解析命令行参数获取端口号
  5. 客户端使用该端口号创建和绑定Socket
  6. 服务器知道每个客户端的端口号，并使用这些端口号连接到客户端

信号处理

程序使用信号处理机制来实现优雅关闭：

signal(SIGINT, signalHandler);
signal(SIGTERM, signalHandler);

这两行代码注册了信号处理函数，当程序接收到SIGINT（通常是按Ctrl+C）或SIGTERM（通常是系统发送的终止信号）时，会调用signalHandler函数。在这个函数中，程序会清理资源并正常退出。

多线程连接

服务器使用多线程来并行连接到所有客户端：

std::vector<std::thread> connectionThreads;
for (int i = 0; i < numClients; i++) {if (clientPids[i] > 0) {int port = basePort + i;connectionThreads.push_back(std::thread(clientConnectionThread, port, i));}
}

这样可以同时尝试连接到所有客户端，而不是一个接一个地连接，提高了效率。

条件变量同步

服务器使用条件变量来等待所有客户端连接完成：

{std::unique_lock<std::mutex> lock(mtx);if (!allClientsConnected) {std::cout << "Waiting for all clients to connect..." << std::endl;cv.wait(lock, []{ return allClientsConnected; });}
}

当所有客户端都连接成功后，allClientsConnected变量会被设置为true，条件变量会通知主线程继续执行。

总结

本文介绍了如何在Linux环境下实现一个服务器程序，该程序能够启动多个客户端进程，并通过Socket与这些客户端进行通信。主要特点包括：

  1. 可配置的客户端数量
  2. 动态端口分配
  3. 并行连接
  4. 广播消息
  5. 确认机制
  6. 优雅关闭

这个示例展示了多进程、Socket通信、多线程和同步机制的综合应用，可以作为网络编程的参考实现。

进一步改进

这个示例还可以进一步改进，例如：

  1. 添加错误恢复机制
  2. 实现客户端自动重连
  3. 添加消息队列
  4. 实现更复杂的通信协议
  5. 添加安全机制（如TLS加密）

相关文章：

  • 学习路之PHP--easyswoole操作数据库
  • 性能测试工具选型指南
  • UNICEODE_STRING
  • 【Markdown基础语法】
  • Oracle/openGauss中，DATE/TIMESTAMP与数字日期/字符日期比较
  • 黑马点评项目02——商户查询缓存（缓存穿透、缓存雪崩、缓存击穿）以及细节
  • 解析C++排序算法
  • vue-seamless-scroll 结束从头开始，加延时后滚动
  • 影楼精修-AI追色算法解析
  • 定点小数 不需要指数部分 不采用移码
  • 网络渗透基础：信息收集
  • Animate CC CreateJS 技术50道测试题目
  • Python应用while嵌套循环
  • MySQL 索引和事务
  • 【JavaScript 高级】事件循环机制详解
  • 如何站在指标体系之巅看智能数据建模产品(GAI)
  • docker常见考点
  • JS入门——JS引入方式
  • 收集飞花令碎片——C语言（数组+函数）
  • 简单三步FastAdmin 开源框架的安装
  • 一个教做网页的网站/潮州seo
  • logo网站在线制作/杭州网站排名seo
  • 广州app开发外包/seodao cn
  • 新手学做网站下载/百度seo如何优化
  • 如何做网站联盟/班级优化大师是干什么用的
  • 西安做网站哪家好/营销广告文案