网络编程day4

最新推荐文章于 2024-07-19 16:09:28 发布
最新推荐文章于 2024-07-19 16:09:28 发布
阅读量123 收藏
点赞数 1
文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crispy715/article/details/126352518
版权

多进程并发服务器

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<sys/wait.h>
#include<signal.h>
#include<stdlib.h>
//打印错误信息的宏函数
#define ERR_MSG(msg) do{\
	fprintf(stderr,"__%d__",__LINE__);\
	perror(msg);\
}while(0);
#define PORT 8888    //1024~49151
#define IP "192.168.31.166"   //本机IP,用ifconfig查看

typedef void (*sighandler_t)(int);
int rcv_cli_msg(int newfd,struct sockaddr_in cin);

void handler(int sig)
{
	while(waitpid(-1,NULL,WNOHANG)>0);
}
int main(int argc, const char *argv[])
{
	//捕获17号信号 SIGCHLD
	sighandler_t s=signal(17,handler);
	if(SIG_ERR==s)
	{
		ERR_MSG("signal");
		return -1;
	}

	//创建流式套接字
	int sfd=socket(AF_INET,SOCK_STREAM,0);
	if(sfd<0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create success\n");

	//允许端口快速复用
	int reuse=1;
	if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse))<0)
	{
		ERR_MSG("setsockopt");
		return -1;
	}
	//填充地址信息结构体,真实的地址信息结构体与协议族相关
	//AF_INET,所以详情请看man 7 ip
	struct sockaddr_in sin;
	sin.sin_family =AF_INET;
	sin.sin_port =htons(PORT);           //网络字节序的端口号
	sin.sin_addr.s_addr=inet_addr(IP);            //网络字节序的IP地址
	//将地址信息结构体绑定到套接字上
	if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin))<0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");
	//将套接字设置为被动监听状态,让内核去监听是否有客户端连接;
	if(listen(sfd,10)<0)
	{
		ERR_MSG("listen");
		return -1;
	}
	printf("listen success\n");
	struct sockaddr_in cin;
	socklen_t addrlen=sizeof(cin);
	pid_t pid=0;
	//从已完成连接的队列头中，取出一个客户端的信息，创建生成一个新的套接字文件描述符
	//该文件描述符才是与客户端通信的文件描述符！
	while(1)
	{
		//父进程只负责连接
		int newfd =accept(sfd,(struct sockaddr*)&cin,&addrlen);
		if(newfd<0)
		{
			ERR_MSG("accept");
			return -1;
		}
		//网络字节序的IP-->点分十进制  网络字节顺序的port-->本机字节序
		printf("[%s : %d] newfd = %d\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd);
		pid=fork();
		if(pid>0)
		{
			close(newfd);
		}else if(pid==0)
		{
			close(sfd);
			//子进程运行，只负责与客户端交互
			rcv_cli_msg(newfd,cin);
			close(newfd);
			//子进程只负责交互，所以不能让子进程继续往后运行
			exit(0);
		}
		else{
			ERR_MSG("fork");
			return -1;
		}
	}
	close(sfd);
	return 0;
}
int rcv_cli_msg(int newfd,struct sockaddr_in cin)
{
	char buf[128]="";
	ssize_t res=0;
	while(1)
	{
		bzero(buf,sizeof(buf));
		//循环接收
		res=recv(newfd,buf,sizeof(buf),0);
		if(res<0)
		{
			ERR_MSG("recv");
			return -1;
		}else if(0==res)
		{
			printf("[%s : %d] newfd = %d客户端退出\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd);
			break;
		}
		printf("[%s : %d] newfd = %d : %s\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,buf);

		//发送数据
		strcat(buf,"*_*");  //可以改成从终端获取
		if(send(newfd,buf,sizeof(buf),0)<0)
		{
			ERR_MSG("send");
			return -1;
		}
		printf("send success\n");
	}

	return 0;
}

多线程并发服务器 

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
//打印错误信息的宏函数
#define ERR_MSG(msg) do{\
	fprintf(stderr,"__%d__",__LINE__);\
	perror(msg);\
}while(0);
#define PORT 8888    //1024~49151
#define IP "192.168.31.166"   //本机IP,用ifconfig查看
struct msg
{
	int newfd;
	struct sockaddr_in cin;
};
void *rcv_cli_msg(void *arg);
int main(int argc, const char *argv[])
{
	//创建流式套接字
	int sfd=socket(AF_INET,SOCK_STREAM,0);
	if(sfd<0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create success\n");

	//允许端口快速复用
	int reuse=1;
	if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse))<0)
	{
		ERR_MSG("setsockopt");
		return -1;
	}
	//填充地址信息结构体,真实的地址信息结构体与协议族相关
	//AF_INET,所以详情请看man 7 ip
	struct sockaddr_in sin;
	sin.sin_family =AF_INET;
	sin.sin_port =htons(PORT);           //网络字节序的端口号
	sin.sin_addr.s_addr=inet_addr(IP);            //网络字节序的IP地址
	//将地址信息结构体绑定到套接字上
	if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin))<0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");
	//将套接字设置为被动监听状态,让内核去监听是否有客户端连接;
	if(listen(sfd,10)<0)
	{
		ERR_MSG("listen");
		return -1;
	}
	printf("listen success\n");
	struct sockaddr_in cin;
	socklen_t addrlen=sizeof(cin);
	int newfd=0;
	pthread_t tid;
	struct msg cliInfo;
	//从已完成连接的队列头中，取出一个客户端的信息，创建生成一个新的套接字文件描述符
	//该文件描述符才是与客户端通信的文件描述符！
	while(1)
	{
		int newfd =accept(sfd,(struct sockaddr*)&cin,&addrlen);
		if(newfd<0)
		{
			ERR_MSG("accept");
			return -1;
		}
		//网络字节序的IP-->点分十进制  网络字节顺序的port-->本机字节序
		printf("[%s : %d] newfd = %d\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd);
		cliInfo.newfd=newfd;
		cliInfo.cin=cin;
		if(pthread_create(&tid,NULL,rcv_cli_msg,(void*)&cliInfo)!=0)
		{
			ERR_MSG("pthread_create");
			return -1;
		}
	}
	close(sfd);
	return 0;
}
void *rcv_cli_msg(void *arg)
{
	//分离分支线程
	pthread_detach(pthread_self());
	int newfd=(*(struct msg*)arg).newfd;
	struct sockaddr_in cin=(*(struct msg*)arg).cin;
	char buf[128]="";
	ssize_t res=0;
	while(1)
	{
		bzero(buf,sizeof(buf));
		//循环接收
		res=recv(newfd,buf,sizeof(buf),0);
		if(res<0)
		{
			ERR_MSG("recv");
			break;
		}else if(0==res)
		{
			printf("[%s : %d] newfd = %d客户端退出\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd);
			break;
		}
		printf("[%s : %d] newfd = %d : %s\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,buf);

		//发送数据
		strcat(buf,"*_*");  //可以改成从终端获取
		if(send(newfd,buf,sizeof(buf),0)<0)
		{
			ERR_MSG("send");
			break;
		}
		printf("send success\n");
	}
	close(newfd);
	pthread_exit(NULL);
}

 TCP本地通信

//服务器
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<sys/un.h>
//打印错误信息的宏函数
#define ERR_MSG(msg) do{\
	fprintf(stderr,"__%d__",__LINE__);\
	perror(msg);\
}while(0);
struct msg
{
	int newfd;
	struct sockaddr_un cin;
};
void *rcv_cli_msg(void *arg);
int main(int argc, const char *argv[])
{
	//创建流式套接字
	int sfd=socket(AF_UNIX,SOCK_STREAM,0);
	if(sfd<0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create success\n");

	//判断要绑定的文件是否存在
	//如果存在，则删除该文件
	if(access("./unix",F_OK)==0)
	{
		//删除文件
		if(unlink("./unix")<0)
		{
			ERR_MSG("unlink");
			return -1;
		}
	}
	//填充地址信息结构体,真实的地址信息结构体与协议族相关
	//AF_INET,所以详情请看man 7 ip
	struct sockaddr_un sin;
	sin.sun_family =AF_UNIX;
	strcpy(sin.sun_path,"./unix");
	//将地址信息结构体绑定到套接字上
	if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin))<0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");
	//将套接字设置为被动监听状态,让内核去监听是否有客户端连接;
	if(listen(sfd,10)<0)
	{
		ERR_MSG("listen");
		return -1;
	}
	printf("listen success\n");
	struct sockaddr_un cin;
	socklen_t addrlen=sizeof(cin);
	int newfd=0;
	pthread_t tid;
	struct msg cliInfo;
	//从已完成连接的队列头中，取出一个客户端的信息，创建生成一个新的套接字文件描述符
	//该文件描述符才是与客户端通信的文件描述符！
	while(1)
	{
		int newfd =accept(sfd,(struct sockaddr*)&cin,&addrlen);
		if(newfd<0)
		{
			ERR_MSG("accept");
			return -1;
		}
		//网络字节序的IP-->点分十进制  网络字节顺序的port-->本机字节序
		printf("newfd = %d\n",newfd);
		cliInfo.newfd=newfd;
		cliInfo.cin=cin;
		if(pthread_create(&tid,NULL,rcv_cli_msg,(void*)&cliInfo)!=0)
		{
			ERR_MSG("pthread_create");
			return -1;
		}
	}
	close(sfd);
	return 0;
}
void *rcv_cli_msg(void *arg)
{
	//分离分支线程
	pthread_detach(pthread_self());
	int newfd=(*(struct msg*)arg).newfd;
	struct sockaddr_un cin=(*(struct msg*)arg).cin;
	char buf[128]="";
	ssize_t res=0;
	while(1)
	{
		bzero(buf,sizeof(buf));
		//循环接收
		res=recv(newfd,buf,sizeof(buf),0);
		if(res<0)
		{
			ERR_MSG("recv");
			break;
		}else if(0==res)
		{
			printf("newfd = %d客户端退出\n",newfd);
			break;
		}
		printf("newfd =%d : %s\n",newfd,buf);

		//发送数据
		strcat(buf,"*_*");  //可以改成从终端获取
		if(send(newfd,buf,sizeof(buf),0)<0)
		{
			ERR_MSG("send");
			break;
		}
		printf("send success\n");
	}
	close(newfd);
	pthread_exit(NULL);
}
//客户端
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<string.h>
#include<sys/un.h>
//打印错误信息的宏函数
#define ERR_MSG(msg) do{\
	fprintf(stderr,"__%d__",__LINE__);\
	perror(msg);\
}while(0);
int main(int argc, const char *argv[])
{
	//创建流式套接字
	int sfd=socket(AF_UNIX,SOCK_STREAM,0);
	if(sfd<0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create success\n");

	//绑定客户端地址信息结构体-->非必须绑定
	
	//填充要连接服务器的地址信息结构体
	struct sockaddr_un sin;
	sin.sun_family =AF_UNIX;
	strcpy(sin.sun_path,"./unix");

	//连接服务器connect
	if(connect(sfd,(struct sockaddr*)&sin,sizeof(sin))<0)
	{
		ERR_MSG("connect");
		return -1;
	}
	char buf[128]="";
	ssize_t res=0;
	while(1)
	{
		//发送
		printf("请输入>>>");
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf)-1]=0;
		if(send(sfd,buf,sizeof(buf),0)<0)
		{
			ERR_MSG("send");
			return -1;
		}
		printf("send success\n");
		//接收
		bzero(buf,sizeof(buf));
		res=recv(sfd,buf,sizeof(buf),0);
		if(res<0)
		{
			ERR_MSG("recv");
			return -1;
		}
		else if(res==0)
		{
			printf("server is offline\n");
			return -1;
		}
		printf("%ld:%s\n",res,buf);
		//关闭套接字
	}
	close(sfd);
	return 0;
}

 UDP本地通信

//客户端
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<string.h>
#include<sys/un.h>
//打印错误信息的宏函数
#define ERR_MSG(msg) do{\
	fprintf(stderr,"__%d__",__LINE__);\
	perror(msg);\
}while(0);
int main(int argc, const char *argv[])
{
	if(argc<2)
	{
		fprintf(stderr,"请输入客户端要绑定的文件名\n");
		return -1;
	}
	//创建流式套接字
	int sfd=socket(AF_UNIX,SOCK_DGRAM,0);
	if(sfd<0)
	{
		ERR_MSG("socket");
		return -1;
	}
	printf("create success\n");
	//判断要绑定的文件是否存在
	//如果存在，则删除该文件
	if(access(argv[1],F_OK)==0)
	{
		//删除文件
		if(unlink(argv[1])<0)
		{
			ERR_MSG("unlink");
			return -1;
		}
	}
	struct sockaddr_un cin;
	cin.sun_family =AF_UNIX;
	strcpy(cin.sun_path,argv[1]);
	//绑定客户端地址信息结构体-->必须绑定
	if(bind(sfd,(struct sockaddr*)&cin,sizeof(cin))<0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");
	struct sockaddr_un sin;
	sin.sun_family =AF_UNIX;
	strcpy(sin.sun_path,"udp_unix");
	struct sockaddr_un rcv_addrmsg;
	socklen_t addrlen=sizeof(rcv_addrmsg);
	char buf[128]="";
	ssize_t res=0;
	while(1)
	{
		//发送
		printf("请输入>>>");
		fgets(buf,sizeof(buf),stdin);
		buf[strlen(buf)-1]=0;
		if(sendto(sfd,buf,sizeof(buf),0,(struct sockaddr*)&sin,sizeof(sin))<0)
		{
			ERR_MSG("sendto");
			return -1;
		}
		printf("send success\n");
		//接收
		bzero(buf,sizeof(buf));
		res=recvfrom(sfd,buf,sizeof(buf),0,(struct sockaddr*)&rcv_addrmsg,&addrlen);
		if(res<0)
		{
			ERR_MSG("recv");
			return -1;
		}
		else if(res==0)
		{
			printf("server is offline\n");
			return -1;
		}
		printf("%s:%s\n",rcv_addrmsg.sun_path,buf);
		//关闭套接字
	}
	close(sfd);
	return 0;
}
//服务器
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<string.h>
#include <stdlib.h>
#include<sys/un.h>
//打印错误信息的宏函数
#define ERR_MSG(msg) do{\
	fprintf(stderr,"__%d__",__LINE__);\
	perror(msg);\
}while(0);
int main(int argc, const char *argv[])
{
	//判断要绑定的文件是否存在
	//如果存在，则删除该文件
	if(access("./unix",F_OK)==0)
	{
		//删除文件
		if(unlink("./unix")<0)
		{
			ERR_MSG("unlink");
			return -1;
		}
	}
	//创建报式套接字
	int sfd=socket(AF_UNIX,SOCK_DGRAM,0);
	if(sfd<0)
	{
		ERR_MSG("socket");
		return -1;
	}
	//填充服务器的IP地址以及端口号
	struct sockaddr_un sin;
	sin.sun_family =AF_UNIX;
	strcpy(sin.sun_path,"./udp_unix");
	//绑定服务器的地址信息结构体
	if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin))<0)
	{
		ERR_MSG("bind");
		return -1;
	}
	printf("bind success\n");
	struct sockaddr_un cin;
	socklen_t addrlen=sizeof(cin);
	char buf[128]="";
	while(1)
	{
		bzero(buf,sizeof(buf));
		//接收
		if(recvfrom(sfd,buf,sizeof(buf),0,(struct sockaddr*)&cin,&addrlen)<0)
		{
			ERR_MSG("recvfrom");
			return -1;
		}
		printf("%s : %s\n",cin.sun_path,buf);
	//发送
	strcat(buf,"*_*");
	//谁发给我，我发还给谁
	if(sendto(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&cin, sizeof(cin)) < 0)
	{
		ERR_MSG("sendto");
		return -1;
	}
	printf("sendto success\n");
	}
	//关闭套接字
	close(sfd);
	return 0;
}

 

crispy715
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux学习之旅（29）----循环服务器模型
孔晨瑞的博客
04-09 263
使用套接字编程的服务器模型主要包括：循环（轮询）服务器模型、并发服务器模型和IO复用服务器模型。 套接字函数错误处理 在前几篇文章中的程序中，没有对程序进行出错处理，这是一个非常不好的习惯，在这里我们将出错函数进行了封装。下面直接使用封装之后的函数就好了。 #ifndef SOCKETERRORHANDING #define SOCKETERRORHANDING #include &lt...
Linux网络编程服务器模型选择之循环服务器
weixin_30263073的博客
03-22 128
在网络程序里面，通常都是一个服务器处理多个客户机，为了出个多个客户机的请求，服务器端的程序有不同的处理方式。本节开始介绍Linux下套接字编程的服务器模型选择，主要包括循环服务器模型、并发服务器模型、IO复用服务器模型等，这也是我们常见的几种网络服务器模型。其中基本可以分为两大类， 1. 循环服务器：循环服务器在同一时刻只能响应一个客户端的请求，是比较简单的一种模型； 2. 并发服务...
服务器模型：循环服务器（TCP）和并发服务器（TCP）
weixin_57723364的博客
09-15 1742
服务器模型：循环服务器（TCP）和并发服务器（TCP）搭建
【Linux网络编程】循环服务器之TCP模型
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
07-29 867
00. 目录 文章目录00. 目录01. 概述02. TCP循环服务器实现方法03. TCP循环服务器模型04. TCP循环服务器实现05. 附录 01. 概述 服务器设计技术有很多，按使用的协议来分有 TCP 服务器和 UDP 服务器，按处理方式来分有循环服务器和并发服务器。 循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器（多对一），为了处理客户的请求，对服务端的程序就提出了特殊的要求。 目前最常用的服务器模型 循环服务器：服务器在同一时刻只能响应一个客户端的请求。
循环服务器，并发服务器模型以及I/O多路转接模型
xinianbuxiu的博客
12-04 1156
一、基于TCP/IP协议的基本循环服务器 tcp_server.c #include #include #include #include #include #include #include #define PORT 3333 #define MAX_SIZE 1024 int main() { int sockfd; int new_fd; s
网络编程day1
crispy715的博客
08-10 60
网络编程
网络编程day4_下 (1).doc
10-08
【网络编程day4_下 (1).doc】的笔记主要涉及了SQLite3数据库在嵌入式环境中的使用，这是网络编程中的一个重要组成部分，特别是在需要在本地存储数据的应用场景下。SQLite3是一个轻量级的、自包含的、无服务器的、SQL...
DAY 8 网络编程 数据库
10-20
DAY 8 网络编程 数据库
第一章网络编程Day1
09-19
网络编程Day1 本资源主要介绍了网络编程的基础知识，包括网络编程的概念、联网协议和层、OSI七层模型、TCP/IP协议、网络接口与物理层、网络层、传输层、应用层等内容。 1. 网络编程的概念 网络编程就是进程间...
python网络编程DAY01.txt
04-27
1.网络编程 （4天） 2.进程线程 （5天） 3.MongoDB 数据库 （4天） 4.正则表达式 （1.5天） 5.项目（2.5天） 6. git的使用（1天） 网络编程 网络功能 : 数据传输 ISO(国际标准化组织) OSI七层模型 ---》 网络...
day23_网络编程.pdf
11-02
"day23_网络编程.pdf" 今天我们要讨论的是网络编程的基础知识，包括软件架构、网络通信协议、网络编程三要素、Socket套接字、ServerSocket、文件上传和自定义服务器。 首先，让我们来了解软件架构。软件架构可以...
服务器模型
朝辞暮见的博客
06-03 1256
1. 在网络程序里面，通常都是一个服务器处理多个客户机。为了处理多个客户机的请求，服务器端的程序有不同的处理方式。目前最常用的服务器模型：1）循环服务器：循环服务器在同一个时刻只能响应一个客户端的请求2）并发服务器：并发服务器在同一个时刻可以响应多个客户端的请求 2. 循环服务器模型无论是TCP循环服务器还是UDP循环服务器，其本质就是一个while循环，这种模型低效也很少使用，本博文不再叙述。 ...
Linux 网络编程——并发服务器的三种实现模型
热门推荐
秋叶原 && Mike || 麦克
05-12 9万+
服务器设计技术有很多，按使用的协议来分有 TCP 服务器和 UDP 服务器，按处理方式来分有循环服务器和并发服务器。循环服务器与并发服务器模型在网络程序里面，一般来说都是许多客户对应一个服务器（多对一），为了处理客户的请求，对服务端的程序就提出了特殊的要求。目前最常用的服务器模型有：·循环服务器：服务器在同一时刻只能响应一个客户端的请求·并发服务器：服务器在同一时刻可以响应多个客户端的请求UDP ...
linux网络编程之并发服务器的三种实现模型 （超级经典）
码莎拉蒂
03-12 5491
转载 ： http://blog.csdn.net/tennysonsky/article/details/45671215 服务器设计技术有很多，按使用的协议来分有 TCP 服务器和 UDP 服务器，按处理方式来分有循环服务器和并发服务器。 循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器（多对一），为了处理客户的请求，对服务端的程序就提出
网络协议-SOTP 协议格式
ziyunLLL的博客
07-19 286
SOTP（Secure Overlay Transport Protocol）是一种安全的覆盖层传输协议，旨在提供增强的安全性和功能。2.密钥管理：密钥的管理和交换是协议安全的重要部分，通常使用公钥基础设施（PKI）或密钥交换协议（如 Diffie-Hellman）。1.安全性：确保加密算法和认证算法的安全性。常用的加密算法包括 AES，常用的认证算法包括 HMAC-SHA256。3.性能：加密和认证会增加计算开销，需要在安全性和性能之间找到平衡。SOTP 协议格式的一般结构。
【Socket 编程】基于UDP协议建立多人聊天室
最新发布
稻草人敲代码的博客
07-19 290
对于服务端来说，除了要接收消息之外，还要实现一个路由转发模块，该路由转发模块可以将相应发送给所有连接的客户端。而对于客户端来说，除了要发送消息给聊天室，还要能实时看到其它所有客户端的消息。下面来看看具体实现的代码，代码只给出核心模块，其余代码模块代码可以借鉴我之前的博客。具体来说，服务器类实现的功能只有收消息。
27_MobileNetV3网络详解
https://github.com/foxpup11?tab=repositories
07-17 804
https://www.bilibili.com/video/BV1GK4y1p7uE/?spm_id_from=333.999.0.0&vd_source=7dace3632125a1ef7fd32c285eb2fbac
RTI DDS大数据碎片
qq_33089547的博客
07-17 964
PublicationBuiltingTopicData或SubscriptionBuiltnTopicData样本较大的最常见原因是序列化的TypeCode或TypeObject，但您也可能发送了大量属性（通过7.5.19 PROPERTY QosPolicy（DDS扩展））或具有较大的ContentFilteredTopic筛选器表达式，以及其他大小可变的字段，这可能会导致样本大小较大。如果您尝试发送一个大小大于MTU的DDS样本，但尚未设置DDS级碎片，您将看到IP级碎片。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值