select模型跨平台服务端/客户端

最新推荐文章于 2021-05-09 07:27:59 发布
最新推荐文章于 2021-05-09 07:27:59 发布
阅读量429 收藏
点赞数
分类专栏： C++并发编程实战
原文链接：https://blog.csdn.net/ccf19881030/article/details/100067758
版权

以下是select模型实现的一个简易TCP服务端和客户端，客户端添加了一个命令输入线程

server

#ifdef _WIN32
    //尽量避免早期的宏的引入
    #define WIN32_LEAN_AND_MEAN
    //Windows.h里面的宏和WinSock2里面的宏有重复
    //Windows环境下开发
    #define _WINSOCK_DEPRECATED_NO_WARNINGS
    #include <Windows.h>
    //windows环境下开发网络编程需要引入的socket头文件
    #include <WinSock2.h>
    //windows环境下进行引入动态链接库  WSAStartup
    //在其他系统平台下不能使用  可以将ws2_32.lib 配置到工程 属性 链接器里面
    //#pragma comment(lib, "ws2_32.lib")
#else
    #include<unistd.h>
    #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>
//内存对齐
struct DataPackage
{
	//long 在64位中是64字节    在32位只有4字节
	int age;
	char name[32];
};
struct DataHeader
{
	short dataLength;
	short cmd;
};
enum CMD
{
	CMD_LOGIN,
	CMD_LOGINOUT,
	CMD_LOGIN_RESULT,
	CMD_LOGOUT_RESULT,
	CMD_NEW_USER_JOIN,
	CMD_ERROR
};
struct Login : public DataHeader
{
	Login()
	{
		dataLength = sizeof(Login);
		cmd = CMD_LOGIN;
	}
	char userName[32];
	char passWord[32];
};
struct LoginOut : public DataHeader
{
	LoginOut()
	{
		dataLength = sizeof(LoginOut);
		cmd = CMD_LOGINOUT;
	}
	char userName[32];
};
struct LoginResult : public DataHeader
{
	LoginResult()
	{
		dataLength = sizeof(LoginResult);
		cmd = CMD_LOGIN_RESULT;
		result = 1;
	}
	int result;
};
struct LogoutResult: public DataHeader
{
	LogoutResult()
	{
		dataLength = sizeof(LoginResult);
		cmd = CMD_LOGOUT_RESULT;
		result = 0;
	}
	int result;
};
struct NewUserJoin : public DataHeader
{
	NewUserJoin()
	{
		dataLength = sizeof(NewUserJoin);
		cmd = CMD_NEW_USER_JOIN;
		sock_id = 0;
	}
	int sock_id;
};
std::vector<SOCKET> g_clients;

int process(SOCKET _cSock)
{
	//缓冲区,把消息先放到缓冲区里面
	char szRecv[1024] = {};
	//5接收客户端数据
	int nLen = (int)recv(_cSock, (char*)&szRecv, sizeof(DataHeader), 0);
	DataHeader* header = (DataHeader*)szRecv;
	if (nLen <= 0) {
		printf("客户端<Socket=%d>已退出，任务结束。\n", _cSock);
		return -1;
	}
	switch (header->cmd) {
	case CMD_LOGIN:
	{
		recv(_cSock, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
		//取到消息   把消息对应到消息体里面
		Login* login = (Login*)szRecv;
		printf("收到客户端<Socket=%d>请求：cmd_login 数据长度：%d, userName=%s, passWd = %s \n", _cSock , login->dataLength, login->userName, login->passWord);
		//忽略判断用户名密码是否正确
		LoginResult loginRet;
		send(_cSock, (char*)&loginRet, sizeof(LoginResult), 0);
	}
	break;
	case CMD_LOGINOUT:
	{
		recv(_cSock, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
		LoginOut* logout = (LoginOut*)szRecv;
		printf("收到客户端<Socket=%d>请求：cmd_logout 数据长度：%d, userName=%s \n", _cSock , logout->dataLength, logout->userName);

		//忽略判断用户名密码是否正确
		LogoutResult logoutRet;
		send(_cSock, (char*)&logoutRet, sizeof(LogoutResult), 0);
	}
	break;
	default:
		header->cmd = CMD_ERROR;
		header->dataLength = 0;
		send(_cSock, (char*)&header, sizeof(header), 0);
		break;
	}
    return 0;
}

int main()
{
#ifdef _WIN32
	//创建版本号
	WORD ver = MAKEWORD(2, 2);
	WSADATA dat;
	WSAStartup(ver, &dat);
#endif
	//1 建立一个socket
	//2 bind 绑定用于接收客户端连接的网络端口
	//3 listen 监听网络端口
	//4 accept 阻塞等待接受客户端连接
	//5 send 向客户端发送一条数据
	//6 关闭套接字 close socket

	//1 建立一个socket
	//创建一个AF_INET的套接字，代表ipv4
	//SOCK_STREAM 面向数据流的   还可以选择面向蓝牙的等等
	//IPPROTO_TCP面向tcp的   也可以选择udp等
	SOCKET _sock = socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);

	//2 bind 绑定用于接收客户端连接的网络端口
	sockaddr_in _sin = {};
	_sin.sin_family = AF_INET;
	_sin.sin_port = htons(4567);  //host to net unsigned short 字节序转换
	//设置绑定到那个IP地址上   一台机器有很多地址
#ifdef _WIN32
	_sin.sin_addr.S_un.S_addr = INADDR_ANY; //inet_addr("127.0.0.1");
#else
    _sin.sin_addr.s_addr = INADDR_ANY;
#endif
	if (SOCKET_ERROR == bind(_sock, (sockaddr*)&_sin, sizeof(_sin)))
	{
		printf("ERROR,绑定网络端口失败\n");
	}
	else {
		printf("绑定网络端口成功\n");
	}

	//3 listen 监听网络端口
	//backlog 5  backlog告诉内核使用多大数值创建等待队列，等待请求    一般小于30以内
	if (SOCKET_ERROR == listen(_sock, 5))
	{
		printf("ERROR,监听网络端口失败\n");
	}
	else {
		printf("监听网络端口成功\n");
	}

	while (true) 
	{
		fd_set fdRead;
		fd_set fdWrite;
		fd_set fdExp;
		FD_ZERO(&fdRead);
		FD_ZERO(&fdWrite);
		FD_ZERO(&fdExp);
		FD_SET(_sock, &fdExp);
		FD_SET(_sock, &fdWrite);
		FD_SET(_sock, &fdRead);
                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];
				}
		}
		//select最后一个参数  设置时间t，将select变为非阻塞   查询等待时间，到了t时间没有请求，返回
		//1s 是最大的阻塞时间值，不一定等1s
		timeval t = {1,0};
		//伯克利 socket
		//nfds 第一个参数,是指fd_set集合中所有描述符(socket)范围，socket最大的值加1  在windows下面不产生意义，可以写0，在linux下面代表最大连接数加1
		int ret = select(maxSock+1, &fdRead, &fdWrite, &fdExp, &t);
		if (ret < 0)
		{
			printf("select任务结束。 \n");
			break;
		}
		//判断当前socket是否在当前fdSet集合中
		if (FD_ISSET(_sock, &fdRead)) 
		{
			FD_CLR(_sock, &fdRead);
			//4 accept 阻塞等待接受客户端连接
			//客户端地址
			sockaddr_in clientAddr = {};
			int nAddrLen = (int)sizeof(clientAddr);
			SOCKET _cSock = INVALID_SOCKET;


			//循环accept多次
#ifdef _WIN32
			 _cSock = accept(_sock, (sockaddr*)&clientAddr, &nAddrLen);
#else
			_cSock = accept(_sock, (sockaddr*)&clientAddr, (socklen_t *)&nAddrLen);
#endif
			if (_cSock == INVALID_SOCKET)
			{
				printf("ERROR,接收到无效客户端连接\n");
			}
			else
			{
				for (int n = (int)g_clients.size() - 1; n >= 0; n--)
				{
					NewUserJoin userJoin;
					send(g_clients[n], (const char*)&userJoin, sizeof(NewUserJoin), 0);
				}
				g_clients.push_back(_cSock);
				printf("新客户端加入：ip = %s \n", inet_ntoa(clientAddr.sin_addr));
			}
			
		}
// fdRead结构体在windows系统有fd_count
//		for (size_t n = 0; n < fdRead.fd_count; n++) 
//		{
//			if (-1 == process(fdRead.fd_array[n]))
//			{
//				auto iter = find(g_clients.begin(), g_clients.end(), fdRead.fd_array[n]);
//				if (iter != g_clients.end())
//				{
//					g_clients.erase(iter);
//				}
//			}
//		}
        for(int n = (int)g_clients.size() - 1; n >= 0; n--)
        {
            if(FD_ISSET(g_clients[n], &fdRead))
            {
                if(-1 == process(g_clients[n]))
                {
                    auto iter = g_clients.begin()+n;
                    if(iter != g_clients.end())
                    {
                        g_clients.erase(iter);
                    }
                }
            }

        }
		//printf("空闲处理其他业务\n");
	}
#ifdef _WIN32
	//8 关闭套接字 close socket
//	for (size_t n = g_clients.size() - 1; n >= 0; n--)
        for (int n = (int)g_clients.size() - 1; n >= 0; n--)
	{

		closesocket(g_clients[n]);
	}
	closesocket(_sock);

	//	清楚windows socket环境
	WSACleanup();
#else
        //size_t 是无符号的，大于等于0是永远true的
        for (int n = (int)g_clients.size() - 1; n >= 0; n--)
        {
 
                close(g_clients[n]);
        }
        close(_sock);
#endif
	getchar();
	return 0;
}

EasyTcpClient.hpp


#ifndef _EasyTcpClient_hpp_
#define _EasyTcpClient_hpp_
	//Windows.h里面的宏和WinSock2里面的宏有重复
	//Windows环境下开发
	#ifdef _WIN32
	//尽量避免早期的宏的引入
	#define WIN32_LEAN_AND_MEAN
	#include <Windows.h>
	//windows环境下开发网络编程需要引入的socket头文件
	#include <WinSock2.h>
	//windows环境下进行引入动态链接库  WSAStartup
	//在其他系统平台下不能使用  可以将ws2_32.lib 配置到工程 属性 链接器里面
	#pragma comment(lib, "ws2_32.lib")
#else
	#include<unistd.h>
	#include<arpa/inet.h>
	#include<string.h>
	#define SOCKET int
	#define INVALID_SOCKET  (SOCKET)(~0)
	#define SOCKET_ERROR            (-1)
#endif

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

class EasyTcpClient
{
	SOCKET _sock;
public:
	EasyTcpClient()
	{
		_sock = INVALID_SOCKET;
	}
	// 虚析构函数 
	virtual ~EasyTcpClient()
	{
		Close();
	}
	//初始化socket
	void InitSocket()
	{
		//启动Win sock 2.x环境
#ifdef _WIN32
		//创建版本号
		WORD ver = MAKEWORD(2, 2);
		WSADATA dat;
		WSAStartup(ver, &dat);
#endif
		//1 建立socket
		if (_sock != INVALID_SOCKET)
		{
			//关闭之前连接
			printf("关闭旧连接<socket=%d>.... \n", _sock);
			Close();
		}
		_sock = socket(AF_INET, SOCK_STREAM, 0);
		if (_sock == INVALID_SOCKET) {
			printf("error, build socket faild \n");
		}
		else {
			printf("build success \n");
		}
	}
	//连接服务器
	int Connect(const char* ip, unsigned short port)
	{
		if (_sock == INVALID_SOCKET)
		{
			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
		int ret = connect(_sock, (sockaddr*)&_sin, sizeof(sockaddr_in));
		if (ret == SOCKET_ERROR) {
			printf("<socket=%d>错误, 连接服务器<%s:%d>失败...... \n", _sock, ip, port);
		}
		else {
			printf("<socket=%d>连接服务器<%s:%d>成功....... \n", _sock, ip, port);
		}
		return ret;
	}

	//4 关闭套接字closesocket
	void Close()
	{
		if (_sock != INVALID_SOCKET)
		{
			//清除Win sock 2.x环境	
#ifdef _WIN32
			closesocket(_sock);
			//清除windows socket环境
			WSACleanup();
#else
			close(_sock);
#endif
			_sock = INVALID_SOCKET;
		}
	}

	//处理网络消息
	bool OnRun()
	{
		if (isRun())
		{
			fd_set fdReader;
			FD_ZERO(&fdReader);
			FD_SET(_sock, &fdReader);
			timeval t = { 1, 0 };
			int ret = select(_sock, &fdReader, 0, 0, &t);
			if (ret < 0)
			{
				printf("<socket=%d>select 任务结束1\n", _sock);
				return false;
			}
			if (FD_ISSET(_sock, &fdReader))
			{
				FD_CLR(_sock, &fdReader);
				if (-1 == RecvData(_sock))
				{
					printf("<socket=%d>select任务结束2\n", _sock);
					return false;
				}
			}
			return true;
		}
		return false;
	}
	//是否工作中
	bool isRun()
	{
		return _sock != INVALID_SOCKET;
	}
	//接收数据 粘包 拆包
	int RecvData(SOCKET _cSock)
	{
		//缓冲区,把消息先放到缓冲区里面
		char szRecv[1024] = {};
		//5接收客户端数据
		int nLen = recv(_cSock, (char*)&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;
	}

	//响应网络消息
	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* user_join = (NewUserJoin*)header;
								  printf("<socket=%d>收到服务端消息：CMD_NEW_USER_JOIN 数据长度：%d \n", _sock, user_join->dataLength);
		}
			break;
		}
	}

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

};

#endif

msg.hpp


//防止多次引入 msg.hpp头文件
#ifndef _MSG_HPP_
#define _MSG_HPP_

//内存对齐
struct DataPackage
{
	//long 在64位中是64字节    在32位只有4字节
	int age;
	char name[32];
};
struct DataHeader
{
	short dataLength;
	short cmd;
};
enum CMD
{
	CMD_LOGIN,
	CMD_LOGINOUT,
	CMD_LOGIN_RESULT,
	CMD_LOGOUT_RESULT,
	CMD_NEW_USER_JOIN,
	CMD_ERROR
};
struct Login : public DataHeader
{
	Login()
	{
		dataLength = sizeof(Login);
		cmd = CMD_LOGIN;
	}
	char userName[32];
	char passWord[32];
};
struct LoginOut : public DataHeader
{
	LoginOut()
	{
		dataLength = sizeof(LoginOut);
		cmd = CMD_LOGINOUT;
	}
	char userName[32];
};
struct LoginResult : public DataHeader
{
	LoginResult()
	{
		dataLength = sizeof(LoginResult);
		cmd = CMD_LOGIN_RESULT;
		result = 1;
	}
	int result;
};
struct LogoutResult : public DataHeader
{
	LogoutResult()
	{
		dataLength = sizeof(LoginResult);
		cmd = CMD_LOGOUT_RESULT;
		result = 0;
	}
	int result;
};
struct NewUserJoin : public DataHeader
{
	NewUserJoin()
	{
		dataLength = sizeof(NewUserJoin);
		cmd = CMD_NEW_USER_JOIN;
		sock_id = 0;
	}
	int sock_id;
};

#endif // !_MSG_HPP_

client.cpp


#include "EasyTcpClient.hpp"
//引入c++标准线程库 c++11正式加入标准库  还有第三方线程库pthread
#include<thread>

//传引用写法   在其他平台下会有错误   使用指针
void cmdThread(EasyTcpClient* client)
{
	while (true)
	{
		char cmdBuff[256] = {};
		scanf_s("%s", cmdBuff);
		if (0 == strcmp(cmdBuff, "exit"))
		{
			client->Close();
			printf("退出cmdThread线程 \n");
			break;
		}
		else if (0 == strcmp(cmdBuff, "login"))
		{
			Login login;
			strcpy_s(login.userName, "lanzhibo");
			strcpy_s(login.passWord, "123");
			client->SendData(&login);
		}
		else if (0 == strcmp(cmdBuff, "logout"))
		{
			LoginOut logout;
			strcpy_s(logout.userName, "lanzhibo");
			client->SendData(&logout);
		}
		else
		{
			printf("不支持的命令\n");
		}
	}
}

int main()
{
	EasyTcpClient client;
	client.InitSocket();
	client.Connect("127.0.0.1", 8888);

	//线程 thread scanf是阻塞的   使用线程异步获取输入
	std::thread t1(cmdThread, &client);
	//与主线程分离
	t1.detach();

	while (client.isRun()) {
		client.OnRun();
	}
	client.Close();

	getchar();
	return 0;
}
csdn_dzh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于多线程Select异步模型的的TCP服务端,客户端网络Socket调试工具
11-15
这是我用API封装的,供调试Socket程序用的 有客户端和服务端 两个程序都是基于Select异步模型的,其中服务端还用到了多线程技术,保证了多客户端的连接 都是消息触发和回调的 用多线程就能够保证多客户端的同时连接,要满足更多的客户端连接,要用到线程池模型,有待于更进一步的探讨和研究 QQ:593485230 E-mai:[email protected]
尝试新思路——跨平台Select模型
declarefly的专栏
12-05 518
Select模型
Windows socket之Select模型开发
系统运维
12-21 506
Windowssocketselect模型开发。 套接字select模型是一种比较常用的IO模型。利用该模型可以使Windowssocket应用程序可以同时管理多个套接字。 使用select模型，可以使当执行操作的套接字满足可读可写条件时，给应用程序发送通知。收到这个通知后，应用程序再去调用相应的WindowssocketAPI去执行函数调用。 Select模型的核心是select...
基于Select模型通信程序的编写，编译和执行
weixin_30780649的博客
04-21 597
任务目标 编写Win32程序模拟实现基于Select模型的两台计算机之间的通信，要求编程实现服务器端与客户端之间双向数据传递。客户端向服务器端发送“计算从1到100的奇数和”，服务器回应客户端并给出从1到100的奇数和结果。 核心代码 Server： 1. #include "InitSock.h" 2. #include <stdio.h> 3. #include &...
select跨平台（windows/linux）底层实现区别和陷阱
wangrenhaioylj的博客
08-16 812
目的： 说到select大家可能都很熟悉了，但是在使用过程中还是会有一些比较隐蔽的坑，这篇文章主要是讲一下在使用select实现跨平台通讯库组件的过程中，遇到的因为不同平台（windows、linux）间select底层实现差异导致一个莫名其妙崩溃。 问题描述： linux平台用select实现的网络通讯库在高并发的情况下莫名其妙的崩溃，windows平台却没有任何问题，经过阅读linux fd_set数据结构找到了答案，描述如下： windows、linux平台fd_set数据结构： 1 windows平
select I/O模型 客户端
09-01
select I/O模型 客户端 winsock编程模型，i/o异步入门模型！
C++中I/O模型之select模型实例
09-04
主要介绍了C++中I/O模型的select模型,实例讲述了I/O模型的用法,具有一定的参考借鉴价值,需要的朋友可以参考下
linux下tcp的服务端和客户端代码，一个服务器对应多个客户端 （多线程和select方式创建服务端）
08-30
linux下tcp的服务端和客户端代码，一个服务器对应多个客户端。 服务端程序对应多个客户端的创建方式有两种，如下： 1、每一个客户端创建一个线程。 2、使用IO多路复用的select方式来应对多个客户端。 程序启动命令...
c++版服务端客户端.zip_服务端
07-15
c++版的服务端和客户端 采用select io model
项目(百万并发网络通信架构)3---将服务端、客户端升级为select模型
董哥的黑板报
04-04 966
一、select函数 Unix下的select Unix下的select函数相关基础语法，可以参阅：https://blog.csdn.net/qq_41453285/article/details/89607091 Windows下的select Windows下的select函数与Unix下的select函数语法相同，但是有些语言稍有不同 Unix下的select函数其参数1为...
select函数实现一个服务器与多个客户端的通信
12-06
利用select函数实现I/O复用，可进行一个服务器与多个客户端的通信。-CSU某课内作业
C++ select模型 异步SOCKET 聊天室服务服客户端
03-20
C++ 使用select模型的异步SOCKET通信 聊天室，分为服务器和客户端，简单通信模型，初熟悉select模型
c++实现win socket 编程中的Select I/O模型
01-28
采用C++语言实现，在VS2010下开发，代码中有相关的注释，如发现问题请不吝指教，谢谢
select模型代码实现
10-23
基于select模型的服务端，客户端也有，可直接打开工程运行
linux客户端服务端模型,使用select模型的服务器
weixin_39523529的博客
05-09 84
程序简介：这是一个运用select函数进行IO复用的服务器模型。它的原理是：当一个客户端连接上服务器时，服务器就将其连接的fd加入fd_set集合，等到这个连接准备好读或写的时候，就通知程序进行IO操作，与客户端进行数据通信。它是一个经典的IO复用模型，但当同时连接的客户端数量变大时，fd_set集合就变得很大，而每次要时行IO操作时，都要遍历一次这个集合，导致效率降低，所以它现在基本上被EPOL...
基于select模型的TCP服务器
如风
07-29 8969
之前的一篇博文是基于TCP的服务器和客户机程序，今天在这我要实现一个基于select模型的TCP服务器（仅实现了服务器）。 socket套接字编程提供了很多模型来使服务器高效的接受客户端的请求，select就是其中之一。 了解select模型我们先来看一下的代码： int iResult = recv(s, buffer,1024); 这 是用来接收数据的，在默认的阻塞模式下的套接字里，r
python-网络编程 （个人学习笔记网络篇番外）--I/O模型之IO多路复用 （select，socket模块简单实现多人聊天室。即：单服务端与多客户端同时进行信息交互）
ChengJiang_09的博客
11-14 262
文章目录一、select模块在socket中作用和原理的简单介绍二、程序实现1️⃣.程序内容介绍：2️⃣.代码实现： 一、select模块在socket中作用和原理的简单介绍 select:使单进程可以同时处理多个网络链接的io，select不断的管理负责的所有socket，当某个socket有数据到达时，select会及时通知用户进程。 二、程序实现 1️⃣.程序内容介绍： 1.实现单服务端同时链接多客户端 2.多客户端可同时向服务端发送信息，服务端按发送顺序依次回复信息，同时标明发送者。 2️⃣.代
后端开发是一个涉及广泛技术和工具的领域.docx
最新发布
04-30
后端开发是一个涉及广泛技术和工具的领域，这些资源对于构建健壮、可扩展和高效的Web应用程序至关重要。以下是对后端开发资源的简要介绍： 首先，掌握一门或多门编程语言是后端开发的基础。Java、Python和Node.js是其中最受欢迎的几种。Java以其跨平台性和丰富的库而著名，Python则因其简洁的语法和广泛的应用领域而备受欢迎。Node.js则通过其基于JavaScript的单线程异步I/O模型，为Web开发提供了高性能的解决方案。 其次，数据库技术是后端开发中不可或缺的一部分。关系型数据库（如MySQL、PostgreSQL）和非关系型数据库（如MongoDB、Redis）各有其特点和应用场景。关系型数据库适合存储结构化数据，而非关系型数据库则更适合处理大量非结构化数据。 此外，Web开发框架也是后端开发的重要资源。例如，Express是一个基于Node.js的Web应用开发框架，它提供了丰富的API和中间件支持，使得开发人员能够快速地构建Web应用程序。Django则是一个用Python编写的Web应用框架，它采用了MVC的软件设计模式，使得代码结构更加清晰和易于维护。
华为数字化转型实践28个精华问答glkm.pptx
04-30
华为数字化转型实践28个精华问答glkm.pptx
使用 select 或 poll 的 I/O 复用 TCP 客户端和服务器
06-12
使用 select 或 poll 的 I/O 复用 TCP 客户端和服务器可以提高网络通信的效率。在客户端中，我们可以使用 select 或 poll 监听多个 socket，当有数据可读时，就可以进行读取操作。在服务器中，我们可以使用 select 或 poll 监听多个客户端连接，当有客户端连接请求时，就可以进行连接操作，并创建新的 socket 与客户端通信。同时，使用 select 或 poll 还可以避免阻塞等待，提高程序的并发性和响应速度。需要注意的是，在使用 select 或 poll 时，需要仔细处理返回值和错误码，以及及时关闭已经断开的连接。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值