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

做网站产生的流量费怎么算怎么制作网站详细流程

wzjs 2025/8/28 1:06:43
做网站产生的流量费怎么算,怎么制作网站详细流程,可以做国外购物的网站,wordpress的后台地址在网络编程中，服务器与多个客户端之间的通信是一个常见的需求。本文将介绍如何在Linux环境下实现一个服务器程序，该程序能够启动多个客户端进程，并通过Socket与这些客户端进行通信。 需求分析 我们的目标是实现以下功能： 服务器…

在网络编程中，服务器与多个客户端之间的通信是一个常见的需求。本文将介绍如何在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加密）
http://www.dtcms.com/wzjs/513344.html

相关文章：

  • 自己做返利网站是真的吗求职seo推荐
  • 网站如何做提交的报名表百度竞价推广方案范文
  • 做网站的图片的内存百度开户公司
  • 公司网站建设会计处理网推平台有哪些
  • 官方网站让第三方建设放心吗全网网站快速排名推广软件
  • 做网站设计赚钱吗关键词排名点击
  • 大型网站建设平台站长工具seo综合查询全面解析
  • 合肥网站建设哪家好网络营销比较好的企业
  • 网站开发域名日喀则网站seo
  • 长沙企业网站建立网络营销工资一般多少
  • 做任务刷单的网站是真的吗seo的优点和缺点
  • 做一个网站 如何盈利微信营销方案
  • 企业网站建设 详细方案学电商运营的培训机构
  • 内江网站建设市场调研报告500字
  • 网站目录怎么做企业seo推广外包
  • 建设网站前准备资料百度seo一本通
  • 怎么优化自己的网站b2b免费发布信息平台
  • 平顶山网站建设营销网点机构号
  • 做语文课文网站的好处株洲今日头条新闻
  • 网站建设的业务好做吗网络推广外包要多少钱
  • 扫黄打非网站建设网站关键词优化推广
  • 石狮app网站开发哪家好中国万网域名查询
  • 网站推广广告词怎么做网站赚钱
  • 用织梦做网站百度手机助手app免费下载
  • 电商网站开发app意义苏州seo关键词优化推广
  • 营销网站建设的原则福建seo排名培训
  • 网站建设网页设计毕业论文温州seo网站建设
  • 做企业网站哪家强百度搜索关键词指数
  • 武汉网站程序开发公司seo关键词排名优化技巧
  • 给网站做外链要注意哪些网络推广和网络营销的区别