如何开发高效服务(C++ )

在 C++ 开发高效服务器时，常用的开发模式和设计模式能够帮助你构建高效、可扩展和可维护的服务器。以下是一些常见的模式和设计模式：

1. 并发和并行编程模型

1.1 Reactor 模式

Reactor 模式是一种事件驱动设计模式，广泛用于高性能服务器编程。它使用事件分离机制和事件处理器来管理多路 I/O 事件。典型实现包括使用 select、poll 或 epoll 等系统调用。

核心组件：

  • Event Demultiplexer：如 select 或 epoll，用于等待事件。
  • Event Handler：处理特定事件的回调函数。
  • Synchronous Event De-multiplexer：同步事件分离器，负责监听 I/O 事件。
1.2 Proactor 模式

Proactor 模式是另一种事件驱动设计模式，区别于 Reactor 模式的是它使用异步 I/O 操作。I/O 操作在后台完成，完成后通知应用程序。

核心组件：

  • Asynchronous Operation Processor：执行异步 I/O 操作。
  • Completion Handler：异步操作完成后的回调函数。

2. 设计模式

2.1 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。服务器中的配置管理器或日志管理器通常使用单例模式。

class Singleton {
public:static Singleton& getInstance() {static Singleton instance;return instance;}private:Singleton() {}Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;
};
2.2 工厂模式（Factory）

工厂模式用于创建对象，而不必指定具体类。它使得代码更加灵活和可扩展。服务器中常用于创建各种处理器或服务。

class AbstractProduct {
public:virtual void doSomething() = 0;virtual ~AbstractProduct() {}
};class ConcreteProductA : public AbstractProduct {
public:void doSomething() override {// Implementation for ConcreteProductA}
};class ConcreteProductB : public AbstractProduct {
public:void doSomething() override {// Implementation for ConcreteProductB}
};class Factory {
public:static std::unique_ptr<AbstractProduct> createProduct(char type) {if (type == 'A') return std::make_unique<ConcreteProductA>();if (type == 'B') return std::make_unique<ConcreteProductB>();return nullptr;}
};
2.3 观察者模式（Observer）

观察者模式定义对象间的一对多依赖关系，当一个对象改变状态时，所有依赖它的对象都会收到通知并自动更新。常用于事件系统和通知机制。

class Observer {
public:virtual void update() = 0;
};class Subject {std::vector<std::shared_ptr<Observer>> observers;public:void attach(const std::shared_ptr<Observer>& observer) {observers.push_back(observer);}void notify() {for (const auto& observer : observers) {observer->update();}}
};
2.4 策略模式（Strategy）

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。服务器中常用于动态选择处理算法或策略。

class Strategy {
public:virtual void execute() = 0;
};class ConcreteStrategyA : public Strategy {
public:void execute() override {// Implementation of strategy A}
};class ConcreteStrategyB : public Strategy {
public:void execute() override {// Implementation of strategy B}
};class Context {std::unique_ptr<Strategy> strategy;public:void setStrategy(std::unique_ptr<Strategy> newStrategy) {strategy = std::move(newStrategy);}void executeStrategy() {if (strategy) {strategy->execute();}}
};

3. 多线程编程模型

3.1 线程池（Thread Pool）

线程池模式预先创建一组线程来处理任务，从而避免了频繁创建和销毁线程的开销。它可以提高服务器的性能和响应速度。

class ThreadPool {std::vector<std::thread> workers;std::queue<std::function<void()>> tasks;std::mutex queueMutex;std::condition_variable condition;bool stop;public:ThreadPool(size_t threads) : stop(false) {for (size_t i = 0; i < threads; ++i) {workers.emplace_back([this] {while (true) {std::function<void()> task;{std::unique_lock<std::mutex> lock(this->queueMutex);this->condition.wait(lock, [this] {return this->stop || !this->tasks.empty();});if (this->stop && this->tasks.empty()) return;task = std::move(this->tasks.front());this->tasks.pop();}task();}});}}template<class F>void enqueue(F&& f) {{std::unique_lock<std::mutex> lock(queueMutex);tasks.emplace(std::forward<F>(f));}condition.notify_one();}~ThreadPool() {{std::unique_lock<std::mutex> lock(queueMutex);stop = true;}condition.notify_all();for (std::thread &worker : workers) {worker.join();}}
};
3.2 任务队列（Task Queue）

任务队列是一种将任务排队等待处理的机制。可以与线程池结合使用，实现任务的并行处理。

class TaskQueue {std::queue<std::function<void()>> tasks;std::mutex queueMutex;public:void pushTask(std::function<void()> task) {std::lock_guard<std::mutex> lock(queueMutex);tasks.push(std::move(task));}std::function<void()> popTask() {std::lock_guard<std::mutex> lock(queueMutex);if (tasks.empty()) return nullptr;auto task = tasks.front();tasks.pop();return task;}
};

4. 网络通信模式

4.1 多路复用（Multiplexing）

使用 select、poll 或 epoll 实现多路复用，允许单个线程处理多个网络连接。

#include <sys/epoll.h>int epoll_fd = epoll_create1(0);
struct epoll_event event;
event.events = EPOLLIN;
event.data.fd = listen_fd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &event);while (true) {struct epoll_event events[MAX_EVENTS];int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);for (int n = 0; n < nfds; ++n) {if (events[n].data.fd == listen_fd) {int conn_fd = accept(listen_fd, (struct sockaddr *) &client_addr, &client_len);event.data.fd = conn_fd;epoll_ctl(epoll_fd, EPOLL_CTL_ADD, conn_fd, &event);} else {// Handle I/O for events[n].data.fd}}
}

总结

使用上述开发模式和设计模式，可以构建高效的 C++ 服务器。选择适合的模式和设计模式可以提高代码的可维护性、可扩展性和性能。在实际开发中，可以根据需求组合使用这些模式，构建出高效可靠的服务器应用。

实现一个简单的服务器

以下是一个基于上述开发模式和设计模式的高效 C++ 服务器的示例。该服务器使用了 Reactor 模式、线程池 和其他一些设计模式。

项目结构

我们将项目组织成以下几个部分：

  1. 主程序入口 (main.cpp)
  2. 服务器类 (Server)
  3. 客户端处理类 (ClientHandler)
  4. 线程池类 (ThreadPool)

代码实现

1. 线程池类 (ThreadPool)

我们将先定义一个简单的线程池，用于处理客户端请求。

// ThreadPool.h
#ifndef THREADPOOL_H
#define THREADPOOL_H#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>class ThreadPool {
public:ThreadPool(size_t numThreads);~ThreadPool();void enqueue(std::function<void()> task);private:std::vector<std::thread> workers;std::queue<std::function<void()>> tasks;std::mutex queueMutex;std::condition_variable condition;bool stop;void workerThread();
};#endif // THREADPOOL_H// ThreadPool.cpp
#include "ThreadPool.h"ThreadPool::ThreadPool(size_t numThreads) : stop(false) {for (size_t i = 0; i < numThreads; ++i) {workers.emplace_back(&ThreadPool::workerThread, this);}
}ThreadPool::~ThreadPool() {{std::unique_lock<std::mutex> lock(queueMutex);stop = true;}condition.notify_all();for (std::thread &worker : workers) {worker.join();}
}void ThreadPool::enqueue(std::function<void()> task) {{std::unique_lock<std::mutex> lock(queueMutex);tasks.emplace(std::move(task));}condition.notify_one();
}void ThreadPool::workerThread() {while (true) {std::function<void()> task;{std::unique_lock<std::mutex> lock(queueMutex);condition.wait(lock, [this] { return stop || !tasks.empty(); });if (stop && tasks.empty()) {return;}task = std::move(tasks.front());tasks.pop();}task();}
}
2. 客户端处理类 (ClientHandler)

处理客户端的连接和请求。

// ClientHandler.h
#ifndef CLIENTHANDLER_H
#define CLIENTHANDLER_H#include <unistd.h>
#include <iostream>class ClientHandler {
public:ClientHandler(int clientSocket);void handle();private:int clientSocket;
};#endif // CLIENTHANDLER_H// ClientHandler.cpp
#include "ClientHandler.h"ClientHandler::ClientHandler(int clientSocket) : clientSocket(clientSocket) {}void ClientHandler::handle() {char buffer[1024];ssize_t bytesRead;while ((bytesRead = read(clientSocket, buffer, sizeof(buffer))) > 0) {std::cout << "Received: " << std::string(buffer, bytesRead) << std::endl;write(clientSocket, buffer, bytesRead); // Echo back to client}close(clientSocket);
}
3. 服务器类 (Server)

服务器类使用 epoll 进行多路复用，并利用线程池处理客户端请求。

// Server.h
#ifndef SERVER_H
#define SERVER_H#include <netinet/in.h>
#include <sys/epoll.h>
#include <vector>
#include "ThreadPool.h"
#include "ClientHandler.h"class Server {
public:Server(int port, size_t numThreads);~Server();void run();private:int serverSocket;int epollFd;ThreadPool threadPool;void acceptConnection();void handleClient(int clientSocket);static const int MAX_EVENTS = 10;
};#endif // SERVER_H// Server.cpp
#include "Server.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <fcntl.h>
#include <cstring>
#include <iostream>Server::Server(int port, size_t numThreads) : threadPool(numThreads) {serverSocket = socket(AF_INET, SOCK_STREAM, 0);if (serverSocket == -1) {throw std::runtime_error("Failed to create socket");}int opt = 1;setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));sockaddr_in serverAddr;std::memset(&serverAddr, 0, sizeof(serverAddr));serverAddr.sin_family = AF_INET;serverAddr.sin_addr.s_addr = INADDR_ANY;serverAddr.sin_port = htons(port);if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {throw std::runtime_error("Failed to bind socket");}if (listen(serverSocket, SOMAXCONN) == -1) {throw std::runtime_error("Failed to listen on socket");}epollFd = epoll_create1(0);if (epollFd == -1) {throw std::runtime_error("Failed to create epoll file descriptor");}epoll_event event;event.events = EPOLLIN;event.data.fd = serverSocket;if (epoll_ctl(epollFd, EPOLL_CTL_ADD, serverSocket, &event) == -1) {throw std::runtime_error("Failed to add server socket to epoll");}
}Server::~Server() {close(serverSocket);close(epollFd);
}void Server::run() {epoll_event events[MAX_EVENTS];while (true) {int numEvents = epoll_wait(epollFd, events, MAX_EVENTS, -1);if (numEvents == -1) {throw std::runtime_error("Error during epoll wait");}for (int i = 0; i < numEvents; ++i) {if (events[i].data.fd == serverSocket) {acceptConnection();} else {handleClient(events[i].data.fd);}}}
}void Server::acceptConnection() {int clientSocket = accept(serverSocket, nullptr, nullptr);if (clientSocket == -1) {std::cerr << "Failed to accept client connection" << std::endl;return;}epoll_event event;event.events = EPOLLIN | EPOLLET;event.data.fd = clientSocket;if (epoll_ctl(epollFd, EPOLL_CTL_ADD, clientSocket, &event) == -1) {std::cerr << "Failed to add client socket to epoll" << std::endl;close(clientSocket);}
}void Server::handleClient(int clientSocket) {threadPool.enqueue([clientSocket]() {ClientHandler handler(clientSocket);handler.handle();});
}
4. 主程序入口 (main.cpp)

启动服务器。

// main.cpp
#include "Server.h"int main() {try {Server server(8080, 4); // 端口 8080，4 个线程server.run();} catch (const std::exception &e) {std::cerr << "Error: " << e.what() << std::endl;return 1;}return 0;
}

说明

  1. 线程池：我们定义了一个 ThreadPool 类，预先创建线程来处理任务，避免频繁创建和销毁线程的开销。
  2. 客户端处理：ClientHandler 类用于处理客户端连接，读取客户端数据并将数据回传。
  3. 服务器：Server 类使用 epoll 实现多路复用，监听新连接并将客户端请求交给线程池处理。

通过以上代码，我们创建了一个高效的 C++ 服务器，它利用 epoll 进行多路复用，并使用线程池来处理客户端请求，确保服务器的高性能和高并发处理能力。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/27670.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【七合一】字典词典成语古诗词造句英语单词文库

【七合一】字典词典成语古诗词造句英语单词文库

帝国CMS7.5 UTF-8 系统开源&#xff0c;不限域名 采用静态伪静态&#xff08;会缓存静态文件&#xff09; 一款7合一的字词句诗典籍模板&#xff0c;包含字典、词典、成语、名句、诗词、古籍、英语、作文、等等。是一款养站神器。 作文范文,作文范文可生成word文档下载能自由…
阅读更多...
【面经总结】Java集合 - Map

【面经总结】Java集合 - Map

Map 概述 Map 架构 HashMap 要点 以 散列(哈希表) 方式存储键值对&#xff0c;访问速度快没有顺序性允许使用空值和空键有两个影响其性能的参数&#xff1a;初始容量和负载因子。 初始容量&#xff1a;哈希表创建时的容量负载因子&#xff1a;其容量自动扩容之前被允许的最大…
阅读更多...
矩阵练习2

矩阵练习2

48.旋转图像 规律&#xff1a; 对于矩阵中第 i行的第 j 个元素&#xff0c;在旋转后&#xff0c;它出现在倒数第i 列的第 j 个位置。 matrix[col][n−row−1]matrix[row][col] 可以使用辅助数组&#xff0c;如果不想使用额外的内存&#xff0c;可以用一个临时变量 。 还可以通…
阅读更多...
【Linux】进程_4

【Linux】进程_4

文章目录 五、进程4. 进程状态5. 进程优先级6. 进程的调度和转换 未完待续 五、进程 4. 进程状态 当进程属于挂起状态时&#xff0c;进程的可执行程序代码和数据均会被从内存中换入到磁盘中&#xff0c;此时进程的PCB并没有消失&#xff0c;只要操作系统还需要管理这个进程&a…
阅读更多...
C++11左值、右值

C++11左值、右值

知识回顾&#xff0c;详解引用 简单概括&#xff0c;引用就是给已存在对象取别名&#xff0c;引用变量与其引用实体共用同一块内存空间 左右值区分 注意&#xff1a;不一定左边的都是左值&#xff0c;右边的都是右值 左边的也可能是右值&#xff0c;等号右边的也可能是左值 …
阅读更多...
Linux C语言：函数的基本用法及传参

Linux C语言：函数的基本用法及传参

一、函数的基本用法 1、main函数 int main(int argc, const char * argv[]) { printf("Hello world\n"); return 0; }数据类型 函数名称 (参数) { //.... return 表达式 } 2、函数 函数是一个完成特定功能的代码模块&#xff0c;其程序代码独立&#xff0c;通常要…
阅读更多...
Java注解@Transa1ctional失效特殊情况

Java注解@Transa1ctional失效特殊情况

最近接手了一个项目需要在上面新加一个模块&#xff0c;我这边直接把之前的模块复制一份改改&#xff0c;去掉多余的文件就开始写了&#xff0c;但是就在一小时前&#xff0c;我调试接口的时候突然就发现事务回滚失效了&#xff0c;准确的说是事务都没有正常开启&#xff0c;这…
阅读更多...
Linux vim 文本编辑 操作文本 三种模式

Linux vim 文本编辑 操作文本 三种模式

介绍 vi 是一个经典的行编辑器&#xff0c;支持模式编辑&#xff08;包括普通模式、插入模式和命令模式&#xff09;。 vim 保留vi核心功能的基础上&#xff0c;增加了多级撤销、语法高亮、插件支持等高级功能。 两者的最大区别&#xff0c;简单的来说vim就是vi的增强版 三…
阅读更多...
Kafka生产者消息发送流程原理及源码分析

Kafka生产者消息发送流程原理及源码分析

Kafka是一个分布式流处理平台，它能够以极高的吞吐量处理数据。在Kafka中，生产者负责将消息发送到Kafka集群，而消费者则负责从Kafka集群中读取消息。本文将探讨Kafka生产者消息发送流程的细节，包括消息的序列化、分区分配、记录提交等关键步骤。 先看一个生产者发送消息的代…
阅读更多...
LaDM3IL：多实例学习用于免疫库分类

LaDM3IL：多实例学习用于免疫库分类

一个人的免疫组库由某一时间点的大量适应性免疫受体组成&#xff0c;代表了该个体的适应性免疫状态。免疫组库分类和相关受体识别有可能为新型疫苗的开发做出贡献。大量的实例对免疫组库分类提出了挑战&#xff0c;这可以表述为大规模多实例学习 (MMIL&#xff0c;Massive Mult…
阅读更多...
pdf.js实现web h5预览pdf文件（兼容低版本浏览器）

pdf.js实现web h5预览pdf文件（兼容低版本浏览器）

注意 使用的是pdf.js 版本为 v2.16.105。因为新版本 兼容性不太好&#xff0c;部分手机预览不了&#xff0c;所以采用v2版本。 相关依赖 "canvas": "^2.11.2", "pdfjs-dist": "^2.16.105", "core-js-pure": "^3.37.…
阅读更多...
苹果新型基于home app的骚扰

苹果新型基于home app的骚扰

近期很多用户收到了新型骚扰信息&#xff0c;通过「家庭」邀请。 故障回显&#xff1a; 你会有到一条邀请你加入 Apple 智能家庭的邀请信息&#xff0c;但邀请信息的内容是骚扰信息&#xff0c;且骚扰信息中通常携带链接&#xff0c;千万不要随意打开。 这种骚扰方式暂时没有…
阅读更多...
通信协议—Modbus

通信协议—Modbus

1、modbus简介 Modbus服务器&#xff1a;接收处理来自客户端的请求&#xff0c;并返回相应的响应&#xff1b; Modbus客户端&#xff1a;向Modbus服务器发送请求&#xff0c;并接收服务器返回的响应的设备或程序&#xff1b; 2、modbus poll调试工具下载 modbus poll用于测…
阅读更多...
Python基础教程（二十）：SMTP发送邮件

Python基础教程（二十）：SMTP发送邮件

&#x1f49d;&#x1f49d;&#x1f49d;首先&#xff0c;欢迎各位来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里不仅可以有所收获&#xff0c;同时也能感受到一份轻松欢乐的氛围&#xff0c;祝你生活愉快&#xff01; &#x1f49d;&#x1f49…
阅读更多...
【C语言】assert.h——断言

【C语言】assert.h——断言

文章目录 主要内容调试和发布模式使用示例用法总结与注意事项 断言是一种用于在程序执行过程中进行调试的工具&#xff0c;能够帮助开发者验证程序的某些假设是否为真。如果断言失败&#xff0c;程序会终止&#xff0c;并输出一个错误消息&#xff0c;通常包含出错的文件名和行…
阅读更多...
13【MySQL必知必会】分组数据（GROUP BY，HAVING）

13【MySQL必知必会】分组数据（GROUP BY，HAVING）

SQL语句 /*第13章 分组数据关键词&#xff1a;分组数据&#xff0c;GROUP BY&#xff0c;HAVING*/-- 计算供应商ID为1003的产品数量 SELECT COUNT(*) AS num_prods FROM products WHERE vend_id 1003;-- 按供应商ID分组&#xff0c;统计每个供应商的产品数量 SELECT vend_id,…
阅读更多...
Linux网络工具：跟踪 TCP 连接的命令tcptrack命令详解

Linux网络工具：跟踪 TCP 连接的命令tcptrack命令详解

目录 一、概述 二、 用法 1、基本用法 2、选项 三、安装 1、说明 2、Debian 系统中安装 3、centos中安装 &#xff08;1&#xff09;下载源代码 &#xff08;2&#xff09;编译源代码 &#xff08;3&#xff09;安装 四、示例和输出 1. 显示所有 TCP 连接 2. 只跟…
阅读更多...
微信监控销售防飞单系统，让你的团队业绩稳如泰山！

微信监控销售防飞单系统，让你的团队业绩稳如泰山！

团队中偶尔出现的私单、飞单问题而烦恼不已&#xff1f;你是否渴望拥有一个神器&#xff0c;能够实时监控销售过程&#xff0c;确保团队业绩的稳健增长&#xff1f;今天&#xff0c;就让我们一起探索这款神奇的“微信监控销售防飞单系统”&#xff0c;让你的销售团队如虎添翼&a…
阅读更多...
React 渲染流程分析

React 渲染流程分析

React 页面是由组件组成的&#xff0c;从根组件直到叶组件&#xff0c;内部的组件数通过 Fiber 来保存并触发并发更新。页面的展示分为两部分&#xff0c;首先是初始化&#xff0c;所有组件首次展示&#xff0c;都要进行渲染&#xff0c;之后是更新流程&#xff0c;也就是页面产…
阅读更多...
【利用python制作一个小程序生成爱心】

【利用python制作一个小程序生成爱心】

要利用Python制作一个小程序来生成爱心&#xff0c;我们可以使用字符图形或者利用图形库&#xff08;如turtle&#xff09;来绘制。下面我将分别展示这两种方法。 方法一&#xff1a;字符图形爱心 这种方法使用ASCII字符来模拟爱心的形状。 def print_love():heart [ ♥ …
阅读更多...
最新文章

Copyright @ 2022~2023