封装server类，创建多个server服务

news2025/10/31 12:12:28

（一）封装server类

MessageHeader.hpp

#ifndef _MessageHeader_hpp_
#define _MessageHeader_hpp_
#endif
#pragma once
enum CMD
{
    CMD_LOGIN,
    CMD_LOGIN_RESULT,
    CMD_LOGOUT,
    CMD_LOGOUT_RESULT,
    CMD_NEW_USER_JOIN,
    CMD_ERROR
};

struct DataHeader
{
    short dataLength;
    short cmd;
};

//DataPackage
struct Login : public DataHeader
{
    Login()
    {
        dataLength = sizeof(Login);
        cmd = CMD_LOGIN;
    }
    char userName[32];
    char PassWord[32];
};

struct LoginResult : public DataHeader
{
    LoginResult()
    {
        dataLength = sizeof(LoginResult);
        cmd = CMD_LOGIN_RESULT;
        result = 0;
    }
    int result;
};

struct Logout : public DataHeader
{
    Logout()
    {
        dataLength = sizeof(Logout);
        cmd = CMD_LOGOUT;
    }
    char userName[32];
};

struct LogoutResult : public DataHeader
{
    LogoutResult()
    {
        dataLength = sizeof(LogoutResult);
        cmd = CMD_LOGOUT_RESULT;
        result = 0;
    }
    int result;
};

struct NewUserJoin : public DataHeader
{
    NewUserJoin()
    {
        dataLength = sizeof(NewUserJoin);
        cmd = CMD_NEW_USER_JOIN;
        scok = 0;
    }
    int scok;
};

EasyTcpServer.hpp

#ifdef _EasyTcpServer_hpp_
#define _EasyTcpServer_hpp_
#endif // _EasyTcpServer_hpp_

#ifdef _WIN32
	#define _CRT_SECURE_NO_WARNINGS
	#define _WINSOCK_DEPRECATED_NO_WARNINGS
	#define WIN32_LEAN_AND_MEAN
	#include<windows.h>
	#include<WinSock2.h>
	#pragma comment(lib,"ws2_32.lib")
#else
	#include<unistd.h> //uni std
	#include<arpa/inet.h>
	#include<string.h>

	#define SOCKET int
	#define INVALID_SOCKET  (SOCKET)(~0)
	#define SOCKET_ERROR            (-1)
#endif

#include<stdio.h>
#include<vector>
#include"MessageHeader.hpp"

class EasyTcpServer
{
private:
	SOCKET _sock;
	std::vector<SOCKET>g_clients;
public:
	EasyTcpServer() {
		_sock = INVALID_SOCKET;
	}
	virtual ~EasyTcpServer() {
		Close();
	}

	//初始化Socket
	SOCKET InitSocket() {
#ifdef _WIN32
		//启动Windows socket 2.x环境
		WORD ver = MAKEWORD(2, 2);
		WSADATA dat;
		WSAStartup(ver, &dat);
#endif
		if (INVALID_SOCKET != _sock) {
			printf("<socket = %d>关闭旧连接...\n", _sock);
			Close();
		}
		_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
		if (INVALID_SOCKET == _sock) {
			printf("错误，建立Socket失败...\n");
		}
		else {
			printf("建立Socket=<%d>成功...\n", _sock);
		}
		return _sock;
	}

	//绑定IP和端口号
	int Bind(const char* ip, unsigned short port) {
		/*if (INVALID_SOCKET == _sock) {
			InitSocket();
		}*/
		// 2 bind 绑定用于接受客户端连接的网络端口
		sockaddr_in _sin = {};
		_sin.sin_family = AF_INET;
		_sin.sin_port = htons(port);//host to net unsigned short

#ifdef _WIN32
		if (ip) {
			_sin.sin_addr.S_un.S_addr = inet_addr(ip);
		}
		else {
			_sin.sin_addr.S_un.S_addr = INADDR_ANY;
		}
#else
		if (ip) {
			_sin.sin_addr.s_addr = inet_addr(ip);
		}
		else {
			_sin.sin_addr.s_addr = INADDR_ANY;
		}
#endif
		//作用：给socket绑定端口号与具体位置
		int ret = bind(_sock, (sockaddr*)&_sin, sizeof(sockaddr_in));
		if (SOCKET_ERROR == ret) {
			printf("错误，绑定网络端口<%d>失败...\n", port);
		}
		else {
			printf("绑定网络端口<%d>成功...\n", port);
		}
		return ret;
	}

	//监听端口号
	int Listen(int n) {
		int ret = listen(_sock, n);
		if (SOCKET_ERROR == ret) {
			printf("Socket = <%d>错误，监听网络端口失败...\n", (int)_sock);
		}
		else {
			printf("Socket = <%d>监听网络端口成功...\n", (int)_sock);
		}
		return ret;
	}

	//接受客户端连接
	SOCKET Accept() {
		sockaddr_in clientAddr = {};
		int nAddrLen = sizeof(sockaddr_in);
		SOCKET _cSock = INVALID_SOCKET;
#ifdef _WIN32
		_cSock = accept(_sock, (sockaddr*)&clientAddr, &nAddrLen);
#else
		_cSock = accept(_sock, (sockaddr*)&clientAddr, (socklen_t*)&nAddrLen);
#endif
		if (INVALID_SOCKET == _cSock) {
			printf("Socket = <%d>错误，接收到无效客户端SOCKET...\n", (int)_sock);
		}
		else {
			NewUserJoin userJoin;
			SendDataToAll(&userJoin);
			g_clients.push_back(_cSock);
			printf("Socket = <%d>新客户端加入:socket = %d, IP = %s \n", (int)_sock,(int)_cSock, inet_ntoa(clientAddr.sin_addr));
		}
		return _cSock;
	}
	
	//关闭Socket
	void Close() {
		if (_sock != INVALID_SOCKET) {
#ifdef _WIN32
			for (int n = (int)g_clients.size() - 1; n >= 0; n--)
			{
				closesocket(g_clients[n]);
			}
			closesocket(_sock);
			//清除Windows socket环境
			WSACleanup();
#else
			for (int n = (int)g_clients.size() - 1; n >= 0; n--)
			{
				close(g_clients[n]);
			}
			close(_sock);
#endif
		}
	}
	
	//处理网络消息
	bool OnRun() {
		if (isRun()) {
			//伯克利 socket 
			fd_set fdRead;//描述符（socket）集合
			fd_set fdWrite;
			fd_set fdExp;

			//清理集合
			FD_ZERO(&fdRead);
			FD_ZERO(&fdWrite);
			FD_ZERO(&fdExp);

			//将描述符（socket）加入集合
			FD_SET(_sock, &fdRead);
			FD_SET(_sock, &fdWrite);
			FD_SET(_sock, &fdExp);

			SOCKET maxSock = _sock;
			for (int n = (int)g_clients.size() - 1; n >= 0; n--)
			{
				//判断集合是否在集合中
				FD_SET(g_clients[n], &fdRead);
				if (maxSock < g_clients[n]) {
					maxSock = g_clients[n];
				}
			}
			//nfds 是一个整数值 是指fd_set集合中所有描述符(socket)的范围，而不是数量
			//既是所有文件描述符最大值+1，在Windwos中这个参数可以写0
			timeval t = { 1,0 };
			int ret = select(maxSock + 1, &fdRead, &fdWrite, &fdExp, &t);
			if (ret < 0) {
				printf("select任务结束...\n");
				Close();
				return false;
			}
			//判断描述符（socket）是否在集合中
			if (FD_ISSET(_sock, &fdRead)) {
				FD_CLR(_sock, &fdRead);
				Accept();
			}
			for (int n = (int)g_clients.size() - 1; n >= 0; n--)
			{
				if (FD_ISSET(g_clients[n], &fdRead)) {
					if (-1 == RecvData(g_clients[n])) {
						auto iter = g_clients.begin() + n;//std::vector<SOCKET>::iterator iter = g_clients.begin();
						if (iter != g_clients.end()) {
							g_clients.erase(iter);
						}
					}
				}
			}
			return true;
		}
		return false;
	}
	//是否工作中
	bool isRun(){
		return _sock != INVALID_SOCKET;
	}

	//接受数据 处理粘包 拆分包
	int RecvData(SOCKET _cSock) {
		//缓冲区
		char szRecv[1024] = {};
		// 5 接收客户端的数据
		int nLen = (int)recv(_cSock, szRecv, sizeof(DataHeader), 0);
		DataHeader* header = (DataHeader*)szRecv;

		if (nLen <= 0) {
			printf("客户端<Socket=%d>已退出，任务结束...\n", _cSock);
			return -1;
		}
		//因为已经先将header读取出来了，所以需要修改读取位置
		recv(_cSock, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
		OnNetMsg(_cSock,header);
		return 0;
	}

	//响应网络消息
	virtual void OnNetMsg(SOCKET _cSock,DataHeader* header) {
		switch (header->cmd) {
			case CMD_LOGIN:
			{
				Login* login = (Login*)header;
				printf("收到客户端<Socket=%d>请求:CMD_LOGIN 数据长度:%d,userName = %s passWord = %s\n", _cSock, login->dataLength, login->userName, login->PassWord);
				//忽略判断用户密码是否正确的过程
				LoginResult ret;
				send(_cSock, (char*)&ret, sizeof(LoginResult), 0);
			}
			break;
			case CMD_LOGOUT:
			{
				Logout* logout = (Logout*)header;
				printf("收到客户端<Socket=%d>请求:CMD_LOGOUT szRecv:%d ,userName = %s \n", _cSock, logout->dataLength, logout->userName);

				//忽略判断用户密码是否正确的过程
				LogoutResult ret;
				send(_cSock, (char*)&ret, sizeof(LogoutResult), 0);
			}
			break;
			default:
			{
				DataHeader header = { 0,CMD_ERROR };
				send(_cSock, (char*)&header, sizeof(DataHeader), 0);
			}
			break;
		}
	}
	//发送指定Socket数据
	int SendData(SOCKET _cSock,DataHeader* header) {
		if (isRun() && header) {
			return send(_cSock, (const char*)header, header->dataLength, 0);
		}
		return SOCKET_ERROR;
	}

	void SendDataToAll(DataHeader* header) {
		for (int n = (int)g_clients.size() - 1; n >=0; n--)
		{
			SendData(g_clients[n], header);
		}
	}
private:

};

server.cpp

#include"EasyTcpServer.hpp"
#include<stdio.h>
int main() {
    EasyTcpServer server1;
    server1.InitSocket();
    server1.Bind(nullptr, 4567);
    server1.Listen(5);

    EasyTcpServer server2;
    server2.InitSocket();
    server2.Bind(nullptr, 4568);
    server2.Listen(5);

    while (server1.isRun() || server2.isRun()) {
        server1.OnRun();
        server2.OnRun();
    }
    server1.Close();
    server2.Close();
    printf("已退出。\n");
    getchar();
    return 0;
}

（二）封装client类

EasyTcpClient.hpp

#ifndef _EasyTcpClient_hpp_
#define _EasyTcpClient_hpp_
#endif
#ifdef _WIN32
	#define _CRT_SECURE_NO_WARNINGS
	#define _WINSOCK_DEPRECATED_NO_WARNINGS
	#define WIN32_LEAN_AND_MEAN
	#include<windows.h>
	#include<WinSock2.h>
	#pragma comment(lib,"ws2_32.lib")
#else
	#include<unistd.h> //uni std
	#include<arpa/inet.h>
	#include<string.h>

	#define SOCKET int
	#define INVALID_SOCKET  (SOCKET)(~0)
	#define SOCKET_ERROR            (-1)
#endif

#include<stdio.h>
#include "MessageHeader.hpp"

class EasyTcpClient
{
	SOCKET _sock;
public:
	EasyTcpClient() {
		_sock = INVALID_SOCKET;
	}

	//虚析构函数
	virtual ~EasyTcpClient() {
		Close();
	}

	//初始化socket
	void InitSocket() {
#ifdef _WIN32
		//启动Windows socket 2.x环境
		WORD ver = MAKEWORD(2, 2);
		WSADATA dat;
		WSAStartup(ver, &dat);
#endif
		// 1 建立一个socket
		if (INVALID_SOCKET != _sock) { 
			printf("<socket = %d>关闭旧连接...\n", _sock);
			Close();
		}
		_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
		if (INVALID_SOCKET == _sock)
		{
			printf("错误，建立Socket失败...\n");
		}
		else {
			printf("建立Socket=%d成功...\n",_sock);
		}
	}

	//连接服务器
	int Connect(const char* ip,unsigned short port) {
		if (INVALID_SOCKET == _sock) {
			InitSocket();
		}
		// 2 连接服务器 connect
		sockaddr_in _sin = {};
		_sin.sin_family = AF_INET; 
		_sin.sin_port = htons(port);
#ifdef _WIN32
		_sin.sin_addr.S_un.S_addr = inet_addr(ip);
#else
		_sin.sin_addr.s_addr = inet_addr(ip);
#endif
		printf("<socket = %d>正在连接服务器<IP = %s:PORT = %d>...\n", _sock, ip, port);

		int ret = connect(_sock, (sockaddr*)&_sin, sizeof(sockaddr_in));
		if (SOCKET_ERROR == ret)
		{
			printf("错误，<socket = %d>连接服务器<IP = %s:PORT = %d>失败...\n",_sock,ip,port);
		}
		else {
			printf("<socket = %d>连接服务器<IP = %s:PORT = %d>成功...\n",_sock,ip,port);
		}
		return ret;
	}

	//关闭套接字closesocket
	void Close() {
		if (_sock != INVALID_SOCKET) {
			#ifdef _WIN32
				closesocket(_sock);
				//清除Windows socket环境
				WSACleanup();
			#else
				close(_sock);
			#endif
				_sock = INVALID_SOCKET;
		}
	}

	//查询网络消息
	bool OnRun() {
		if (isRun()) {
			fd_set fdReads;
			FD_ZERO(&fdReads);
			FD_SET(_sock, &fdReads);
			timeval t = { 1,0 };
			int ret = select(_sock + 1, &fdReads, 0, 0, &t);
			if (ret < 0)
			{
				printf("<socket = %d>select任务结束1\n", _sock);
				Close();
				return false;
			}
			if (FD_ISSET(_sock, &fdReads))
			{
				FD_CLR(_sock, &fdReads);

				if (-1 == RecvData(_sock))
				{
					printf("<socket = %d>select任务结束2\n", _sock);
					Close();
					return false;
				}
			}
			return true;
		}
		return false;
	}

	//是否工作中
	bool isRun() {
		return _sock != INVALID_SOCKET;
	}

	//接收数据 处理粘包 拆分包
	int RecvData(SOCKET _cSock)
	{
		//缓冲区
		char szRecv[4096] = {};
		// 5 接收服务端数据
		int nLen = (int)recv(_cSock, szRecv, sizeof(DataHeader), 0);
		DataHeader* header = (DataHeader*)szRecv;
		if (nLen <= 0) 
		{
			printf("<socket = %d>与服务器断开连接，任务结束。\n",_cSock);
			return -1;
		}
		recv(_cSock, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
		OnNetMsg(header);
		return 0;
	}

	//响应网络消息
	virtual void OnNetMsg(DataHeader* header) {
		switch (header->cmd)
		{
			case CMD_LOGIN_RESULT:
			{
				LoginResult* login = (LoginResult*)header;
				printf("<socket = %d>收到服务端消息：CMD_LOGIN_RESULT,数据长度：%d\n",_sock, login->dataLength);
			}
			break;
			case CMD_LOGOUT_RESULT:
			{
				LogoutResult* logout = (LogoutResult*)header;
				printf("<socket = %d>收到服务端消息：CMD_LOGOUT_RESULT,数据长度：%d\n",_sock, logout->dataLength);
			}
			break;
			case CMD_NEW_USER_JOIN:
			{
				NewUserJoin* userJoin = (NewUserJoin*)header;
				printf("<socket = %d>收到服务端消息：CMD_NEW_USER_JOIN,数据长度：%d\n",_sock, userJoin->dataLength);
			}
			break;
		}
	}

	//发送数据
	int SendData(DataHeader* header) {
		if (isRun() && header ) {
			return send(_sock, (const char*)header, header->dataLength, 0);
		}
		return SOCKET_ERROR;
	}
private:

};

MessageHeader.hpp

#ifndef _MessageHeader_hpp_
#define _MessageHeader_hpp_
#endif
#pragma once
enum CMD
{
    CMD_LOGIN,
    CMD_LOGIN_RESULT,
    CMD_LOGOUT,
    CMD_LOGOUT_RESULT,
    CMD_NEW_USER_JOIN,
    CMD_ERROR
};

struct DataHeader
{
    short dataLength;
    short cmd;
};

//DataPackage
struct Login : public DataHeader
{
    Login()
    {
        dataLength = sizeof(Login);
        cmd = CMD_LOGIN;
    }
    char userName[32];
    char PassWord[32];
};

struct LoginResult : public DataHeader
{
    LoginResult()
    {
        dataLength = sizeof(LoginResult);
        cmd = CMD_LOGIN_RESULT;
        result = 0;
    }
    int result;
};

struct Logout : public DataHeader
{
    Logout()
    {
        dataLength = sizeof(Logout);
        cmd = CMD_LOGOUT;
    }
    char userName[32];
};

struct LogoutResult : public DataHeader
{
    LogoutResult()
    {
        dataLength = sizeof(LogoutResult);
        cmd = CMD_LOGOUT_RESULT;
        result = 0;
    }
    int result;
};

struct NewUserJoin : public DataHeader
{
    NewUserJoin()
    {
        dataLength = sizeof(NewUserJoin);
        cmd = CMD_NEW_USER_JOIN;
        scok = 0;
    }
    int scok;
};

client.cpp

#include"EasyTcpClient.hpp"
#include<thread>

void cmdThread(EasyTcpClient* client)
{
    while (true)
    {
        char cmdBuf[256] = {};
        scanf("%s", cmdBuf);
        if (0 == strcmp(cmdBuf, "exit"))
        {
            client->Close();
            printf("退出cmdThread线程\n");
            break;
        }
        else if (0 == strcmp(cmdBuf, "login"))
        {
            Login login;
            strcpy(login.userName, "lyd");
            strcpy(login.PassWord, "lydmm");
            client->SendData(&login);
        }
        else if (0 == strcmp(cmdBuf, "logout"))
        {
            Logout logout;
            strcpy(logout.userName, "lyd");
            client->SendData(&logout);
        }
        else {
            printf("不支持的命令。\n");
        }
    }
}

int main()
{
    //EasyTcpClient client;
    //client.Connect("192.168.1.104", 4567);//Windows IP地址

    EasyTcpClient client2;
    client2.Connect("192.168.206.128",4567);//Linux IP地址

    //EasyTcpClient client3;
    //client3.Connect("192.168.206.129", 4567);//MacOS IP地址

    启动线程
    //std::thread t1(cmdThread, &client);
    //t1.detach();
   
    启动线程
    std::thread t2(cmdThread, &client2);
    t2.detach();

    //启动线程
    /*std::thread t3(cmdThread, &client3);
    t3.detach();*/

    //while (client.isRun() || client2.isRun() || client3.isRun())
    while (client2.isRun())
    {
        //client.OnRun();
        client2.OnRun();
        //client3.OnRun();
    }

    //client.Close();
    client2.Close();
    //client3.Close();

    printf("已退出。\n");
    getchar();
    return 0;
}

实验效果：在Linux系统上运行server服务，在MacOS和Windwos系统上运行client客户端

实验效果：在MacOS系统上运行server服务，在Linux和Windwos系统上运行client客户端 

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

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

相关文章

安装RedisBloom插件

安装RedisBloom插件

前言 安装RedisBloom模块会遇到很多坑&#xff0c;希望你不要和我一样踩的这么全&#x1f60f;。 下载RedisBloom插件 布隆过滤器插件下载地址 github.com/RedisBloom/RedisBloom/releases 在对应的Linux机器下载 wget https://github.com/RedisBloom/RedisBloom/archive/…
阅读更多...
一文搞懂，这几种 API 的不同应用场景

一文搞懂，这几种 API 的不同应用场景

API&#xff0c;即应用程序编程接口&#xff0c;为不同应用程序之间的数据和功能交互提供标准化的方法。在现代软件架构中&#xff0c;各种类型的 API 成为了构建了复杂应用系统的关键部分。而随着技术的发展&#xff0c;越来越多的 API 类型也出现了&#xff0c;例如&#xff…
阅读更多...
Flash Jetson Linux 刷写系统报错处理

Flash Jetson Linux 刷写系统报错处理

目录 报错一&#xff1a;No such file or directory: dtc解决方案 报错二&#xff1a;ERROR sshpass not found 等其他执行刷写的依赖包解决方案 结论 报错一&#xff1a;No such file or directory: ‘dtc’ 在使用 SDK Manager 刷写Jetson Linux 时&#xff0c;在完成了 Cre…
阅读更多...
DD驱动鼠标键盘(驱动级别机器人使用鼠标键盘)

DD驱动鼠标键盘(驱动级别机器人使用鼠标键盘)

官网下载 DD虚拟键盘虚拟鼠标 github下载 GitHub - ddxoft/master 点击下载后&#xff0c;将驱动包下&#xff0c;这里以win7为例 setup运行安装 安装成功后 可以打开电脑管理&#xff0c;可以看见DD虚拟鼠标和键盘 这里以JAVA接入为例 使用管理员权限启动eclipse &#…
阅读更多...
python安装报错error: pybind11 2.10+ requires MSVC 2017 or newer

python安装报错error: pybind11 2.10+ requires MSVC 2017 or newer

python安装报错error: pybind11 2.10 requires MSVC 2017 or newer文章来源&#xff1a;https://www.cnblogs.com/viete/p/16909793.html 下载Build Tools for Visual Studio 2017 &#xff0c;打开后选单个组件&#xff0c;再选VC2017最新版本。 https://download.visualstu…
阅读更多...
第7章：字符串函数

第7章：字符串函数

字符串函数 1.字符串函数 2.举例 select ASCII(A),CHAR_LENGTH(hello),CHAR_LENGTH(我们), LENGTH(hello),LENGTH(我们) from dual;3.举例 ①select CONCAT(emp.last_name,-worked for-,mgr.last_name) "details" from employees emp left join employees mgr on em…
阅读更多...
61.网页设计规则#7_元素之间的空白

61.网页设计规则#7_元素之间的空白

为什么需要空白&#xff1f; 适度的空白使设计看起来整洁、现代和精致。空白传达不同片段信息之间的关系。空白意味着布局元素之间存在看不见的关系。 如何去使用空白&#xff1f; 各部分之间使用大量的空白&#xff1b; 元素组之间使用大量的空白。 在各个元素之间使用空白…
阅读更多...
优化了成本和安装难度后，UWB信标能否取代蓝牙信标？

优化了成本和安装难度后，UWB信标能否取代蓝牙信标？

1 我们做安U3号是要解决什么问题&#xff1f; &#xff08;1&#xff09;信标式设计&#xff0c;解决传统UWB基站安装过程繁琐复杂的问题 传统UWB基站在安装过程中遇上的难题&#xff1a; l 安装位置选取问题&#xff1a;UWB基站的准确度与其安装位置有很大关系&#xff0c;…
阅读更多...
qt实现国际化方法与步骤

qt实现国际化方法与步骤

1. 在程序中所有需要翻译的字符串都用tr封装&#xff0c;如tr("hello"); 2. 在项目文件(.pro)中增加语言翻译文件选项&#xff0c; 如 TRANSLATIONS trans_cn.ts trans_en.ts 3. 在Qt Creator的菜单栏中依次选择“工具”-> ”外部“->“语言家”->&q…
阅读更多...
Windows下安装MySQL数据库（从完全卸载到安装使用图文详细步骤，附安装包）

Windows下安装MySQL数据库（从完全卸载到安装使用图文详细步骤，附安装包）

目录 第一章&#xff1a;如何完全卸载干净mysql教程&#xff08;三个步骤完全卸载&#xff09;1&#xff09;步骤一&#xff1a;卸载程序2&#xff09;步骤二&#xff1a;删除文件3&#xff09;步骤三&#xff1a;删除注册表信息 第二章&#xff1a;下载软件两种方式1&#xff…
阅读更多...
FT2000+ qemu kvm openEuer crash 分析 频繁设置CPU online及cgroup导致进程卡死、不调度故障

FT2000+ qemu kvm openEuer crash 分析 频繁设置CPU online及cgroup导致进程卡死、不调度故障

测试用例1 openEuler 20.03 默认内核 https://hknaruto.blog.csdn.net/article/details/130498823 内核版本信息 突然就坚挺起来&#xff0c;长时间稳定运行 。。。 测试用例2&#xff1a;CentOS8 (16C16G) 十几分钟后&#xff0c;终端已卡死 &#xff0c;两个终端均无响应&a…
阅读更多...
月报总结｜Moonbeam 4月份大事一览

月报总结｜Moonbeam 4月份大事一览

本月&#xff0c;Moonbeam生态扶持进入下一里程碑&#xff01;探索更多优质的早期Web3项目&#xff0c;Moonbeam Accelerator Program已公布进入最终加速孵化阶段的10家初创公司&#xff0c;这些幸运项目将在未来3个月接受顶级孵化公司和专业投资机构的培训&#xff0c;于下半年…
阅读更多...
如何使用LiveData实现Room数据库的数据变化监听？

如何使用LiveData实现Room数据库的数据变化监听？

Room原理 Room是Android中一种轻量级而强大的持久化库&#xff0c;是SQLite的现代化封装和更高级实现方式。它提供了简单的对象映射技术&#xff0c;可用于管理SQLite数据库&#xff0c;支持SQLite的全部功能并可在编译时发现数据库中的错误&#xff0c;保证了数据的安全和稳定…
阅读更多...
【Redis】 事务和锁机制（图文结合，最详细）

【Redis】 事务和锁机制（图文结合，最详细）

目录 一、Redis 事务是什么 二、Redis 事务命令操作 三、Redis 事务中的命令错误处理 3.1、事务中出现命令语法错误 3.2、事务中出现命令逻辑错误 四、事务冲突的解决办法 4.1、事务冲突问题 4.1、方法一&#xff1a;悲观锁 4.2、方法二&#xff1a;乐观锁 一、Redis 事…
阅读更多...
【MyBatis】XML版快速入门——练习题

【MyBatis】XML版快速入门——练习题

目录 1、准备工作 1.1、导入依赖&#xff08;mybatis启动器和mysql驱动&#xff09; 1.2.、yml中配置MyBatis的配置 3、编写domain、mapper、xml 2、数据库准备 2.1、类型表 2.2、老师表 2.3、班级表 2.4、城市表 2.5、学生表 2.6、课程表 2.7、中间表 3、练习题…
阅读更多...
【P3】JMeter HTTP 接口设计

【P3】JMeter HTTP 接口设计

一、简答 HTTP 接口设计 HTTP请求默认值&#xff1a; 配置 http 请求的默认值&#xff0c;比如协议、主机、端口 HTTP信息头管理器&#xff1a; 配置 http 请求的头部参数 HTTP请求&#xff1a; 用于和业务交互 查看结果树&#xff1a; 用于结果展示 二、准备工作 慕慕生…
阅读更多...
嵌入式基础测试手册——基于NXP iMX6ULL开发板（4）

嵌入式基础测试手册——基于NXP iMX6ULL开发板（4）

前 言 本文档适用开发环境： Windows开发环境：Windows 7 64bit、Windows 10 64bit 虚拟机：VMware15.1.0 Linux开发环境：Ubuntu18.04.4 64bit U-Boot：U-Boot-2020.04 Kernel：Linux-5.4.70 Linux SDK：5.4.70_2.3.0 基于测试板卡：创龙科技TLIMX6U-EVM是一款基于NXP…
阅读更多...
数字化供电所业务融合贯通建设方案（ppt可编辑）

数字化供电所业务融合贯通建设方案（ppt可编辑）

本资料来源公开网络&#xff0c;仅供个人学习&#xff0c;请勿商用&#xff0c;如有侵权请联系删除。 1、供电所现状分析 2、供电所数字化转型重点建设要素 三、建设原则 以“数字管理、提质增效”为重点&#xff0c;充分利用“云大物移智”技术&#xff0c;推动人员、设备、…
阅读更多...
IDEA2022版教程下（快键键总结、Debug断点调试总结、22版本idea创建各种工程、关联数据库、常用插件）

IDEA2022版教程下（快键键总结、Debug断点调试总结、22版本idea创建各种工程、关联数据库、常用插件）

8.快捷键的使用 8.1 常用快捷键 1 通用型&#xff08;复制&#xff0c;黏贴&#xff0c;剪贴…&#xff09; 说明快捷键复制代码-copyctrl c粘贴-pastectrl v剪切-cutctrl x撤销-undoctrl z反撤销-redoctrl shift z保存-save allctrl s全选-select allctrl a 2 提高…
阅读更多...
【C++学习】文件操作

【C++学习】文件操作

程序运行时产生的数据都属于临时数据&#xff0c;程序一旦运行结束都会被释放。 通过文件可以将数据持久化。 C中对文件操作要包含头文件 <fstream> 文本类型分为两种&#xff1a; 1.文本文件 ---文件以文本的ASCII码形式存在计算机中 2.二进制文件---文件以文本…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023