网络编程（四）

最新推荐文章于 2024-07-27 14:51:42 发布
最新推荐文章于 2024-07-27 14:51:42 发布
阅读量565 收藏 17
点赞数 27
分类专栏： 网络 文章标签： 网络 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuezhe_____/article/details/139414985
版权

网络编程（四）

服务器模型

–》运行服务器s，运行一个客户端c1,此时连接成功且通信没有问题，再运行一个客户端c2,发现显示connect OK(说明客户端和服务器进行了三次握手，但不代表服务器就一定能处理客户端的业务—》除非服务器执行了accept后拿到与c2通信的新的套接字)，但是c2与服务器的业务对接不了，此时c1选择结束结束业务，此时s也跟着退出了。
实际上：服务器是可以处理多个客户端的业务，其次服务器也不应该因为客户端的退出它自己也退出
因此：服务器模型应该为循环服务器或者并发服务器。

循环服务器

TCP服务器端运行后等待客户端的连接请求。
TCP服务器接受一个客户端的连接后开始处理，完成了客户的所有请求后断开连接
注意：TCP循环服务器同一时刻只能响应一个客户端的请求以及业务的处理。

只有在当前客户的所有请求都完成后，服务器才能处理下一个客户的连接/服务请求。
如果某个客户端一直占用服务器资源，那么其它的客户端都不能被处理。
故：TCP服务器一般很少采用循环服务器模型。

TCP循环服务器设计框架：

socket();
bind();
listen();
while(1)
{
	accept();
	while(1)
	{
		server_com();
	}
}
close();

并发服务器

概念：并发服务器同一时刻可以处理多个客户机的请求
设计思路：并发服务器是在循环服务器基础上优化过来的
如何优化的？？？
（1）每连接一个客户机，服务器立马创建子进程或者子线程来跟新的客户机通信
（accept之后的），服务器不会与客户端进行通信！！！
（2）IO多路复用技术

select 与epoll可连接最大客户端的数量：
在这里插入图片描述

实现并发服务器的方式：

  1. 多进程
  2. 多线程
  3. select函数
  4. poll和epoll（自己查询）

多进程实现并发服务器

最多可以创建1021个进程

思想：主进程专门用于连接多个客户端的请求，若有一个客户端连接进来，主进程就创建一个子进程，用该子进程来创建客户端的业务数据
在这里插入图片描述
在accept之后，创建子进程
server:

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#define BUF_SIZE 20
//tcpserver
int main()
{
	//socket
	int serverfd = socket(AF_INET, SOCK_STREAM,0);
	//判断socket返回值
	if(-1 == serverfd)
	{
		//返回值为-1，代表创建软通道出错，打印出错原因并返回
		perror("socket error");
		return -1;
	}
	//创建软通道成功
	printf("socket ok------\r\n");
	//bind
	struct sockaddr_in stserver;
	//使用struct sockaddr_in结构体接受参数2的参数并强转为struct sockaddr结构体
	stserver.sin_family = AF_INET;
	stserver.sin_port = htons(8888);
	stserver.sin_addr.s_addr = inet_addr("127.0.0.1");
	int ret = bind(serverfd, (struct sockaddr*)&stserver, sizeof(struct sockaddr));
	//判断的返回值
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("bind error");
		return -1;
	}
	//绑定服务端主机成功
	printf("bind ok------\r\n");
	//listen
	ret = listen(serverfd, 5);
	//返回值判断
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("listen error");
		return -1;
	}
	//监听创建成功
	printf("listen ok------\r\n");
	//接受客户端的信息
	struct sockaddr_in stclient;
	//结构体大小
	socklen_t len = sizeof(struct sockaddr);
	//创建收发数据的缓冲区
	char buf[BUF_SIZE] = {0};
	while(1)
	{
		//清空接收数据的缓冲区
		memset(buf, 0, BUF_SIZE);
		//accept
		int newfd = accept(serverfd, (struct sockaddr*)&stclient, &len);
		//返回值为为客户端创建新的软通道
		if(-1 == newfd)
		{
			//创建失败，进行下一次侦听接收
			perror("accept error");
			continue;
		}
		//连接成功并软通道创建成功
		printf("accept ok-----newfd:%d\r\n", newfd);
		//fork
		pid_t pid = fork();
		if(-1 == pid)
		{
			perror("fork error");
			close(newfd);
			continue;
		}
		if(0 == pid)
		{
			while(1)
			{
				memset(buf, 0, BUF_SIZE);
				ret = recv(newfd, buf, BUF_SIZE, 0);
				if(ret <= 0)
				{
					perror("recv error");
					close(newfd);
					exit(0);
				}
				printf("recv%d data:%s\r\n", newfd, buf);
				//send
				send(newfd, buf, BUF_SIZE, 0);
			}
		}
	}
	return 0;
}

client:

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define BUF_SIZE 20
//功能：TCPclient
int main()
{
	//socket
	int clientfd = socket(AF_INET, SOCK_STREAM, 0);
	if(-1 == clientfd)
	{
		perror("socket error");
		return -1;
	}
	//创建软通道成功
	printf("socket ok----\r\n");
	//connect
	struct sockaddr_in serveraddr;
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(8888);
	serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	int ret = connect(clientfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));
	//判断connect的返回值
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("connect error----\r\n");
		return -1;
	}
	//连接服务端成功
	printf("connect ok....\r\n");
	//创建数据缓冲区
	char buf[BUF_SIZE] = {0};
	while(1)
	{
		memset(buf, 0, BUF_SIZE );
		printf("please write:\r\n");
		//从标准输入端口输入数据，存储在buf里
		fgets(buf, BUF_SIZE, stdin);
		//send为发送数据
		ret = send(clientfd, buf, BUF_SIZE, 0);
		//返回值判断
		if(-1 == ret)
		{
			//失败返回原因，不做返回，接受服务端的数据
			perror("send error");
		}
		//清空接收数据的缓冲区
		memset(buf, 0, BUF_SIZE );
		//recv接收数据
		ret = recv(clientfd, buf, BUF_SIZE, 0);
		//返回值判断
		if(-1 == ret)
		{
			//失败返回原因并返回
			perror("recv error");
			return -1;
		}
		//成功打印接受的数据
		printf("recv data : %s\r\n", buf);
	}
	//关闭软通道描述符
	close(clientfd);
	return 0;	
}

在这里插入图片描述

或注意：
子进程不管被杀死或者自己主动选择exit(0)退出，此时子进程的退出资源必须被回收！
如何回收？
思想：让父进程监测子进程的退出状态（信号：SIGCHLD）—》信号注册signal(信号名称，信号处理函数)
代码呈现：

//1、先注册信号
signal(SIGCHLD, handler);
//2、实现信号处理函数handler
void handler(int signum)
{
	//使用waitpid来回收子进程的退出资源
	while(waitpid(-1, NULL, WNOHANG) > 0)
	{
		printf("已成功回收子进程的退出资源!\n");
	}
}

在这里插入图片描述
关于子进程资源一定记得被回收的方法：
在这里插入图片描述
思考：
多进程并发服务器的缺点：每连接一个客户端，就为其创建子进程，客户端数量比较大时，服务器的运行效率就会变低。

多线程实现并发服务器

思想：主进程专门用于连接多个客户端的请求，若有一个客户端连接进来，主进程就创建一个子线程，用该子线程来创建客户端的业务数据

在accept创建子线程

server

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#define BUF_SIZE 20
//tcpserver

void* ThreadFunc(void * arg)
{
	int iClient = *(int *)arg;
	char buf[BUF_SIZE] = {0};
	int ret = -1;
	while(1)
	{
		ret = recv(iClient, buf, BUF_SIZE, 0);
		if(ret <= 0)
		{
			perror("recv error");
			close(iClient);
			pthread_exit("thread exit");
		}
		printf("recv data:%s\r\n", buf);
		send(iClient, buf, BUF_SIZE, 0);
	}
}


int main()
{
	//socket
	int serverfd = socket(AF_INET, SOCK_STREAM,0);
	//判断socket返回值
	if(-1 == serverfd)
	{
		//返回值为-1，代表创建软通道出错，打印出错原因并返回
		perror("socket error");
		return -1;
	}
	//创建软通道成功
	printf("socket ok------\r\n");
	//bind
	struct sockaddr_in stserver;
	//使用struct sockaddr_in结构体接受参数2的参数并强转为struct sockaddr结构体
	stserver.sin_family = AF_INET;
	stserver.sin_port = htons(8888);
	stserver.sin_addr.s_addr = inet_addr("127.0.0.1");
	int ret = bind(serverfd, (struct sockaddr*)&stserver, sizeof(struct sockaddr));
	//判断的返回值
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("bind error");
		return -1;
	}
	//绑定服务端主机成功
	printf("bind ok------\r\n");
	//listen
	ret = listen(serverfd, 5);
	//返回值判断
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("listen error");
		return -1;
	}
	//监听创建成功
	printf("listen ok------\r\n");
	//接受客户端的信息
	struct sockaddr_in stclient;
	//结构体大小
	socklen_t len = sizeof(struct sockaddr);
	//创建收发数据的缓冲区
	char buf[BUF_SIZE] = {0};
	while(1)
	{
		//清空接收数据的缓冲区
		memset(buf, 0, BUF_SIZE);
		//accept
		int newfd = accept(serverfd, (struct sockaddr*)&stclient, &len);
		//返回值为为客户端创建新的软通道
		if(-1 == newfd)
		{
			//创建失败，进行下一次侦听接收
			perror("accept error");
			continue;
		}
		//连接成功并软通道创建成功
		printf("accept ok-----newfd:%d\r\n", newfd);

		//thread
		pthread_t tID = -1;
		if(0 != pthread_create(&tID, NULL, ThreadFunc, &newfd))
		{
			perror("create thread error");
			close(newfd);
			continue;
		}
		printf("create thread ok newfd:%d\r\n", newfd);
	}
	return 0;
}

client:

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define BUF_SIZE 20
//功能：TCPclient
int main()
{
	//socket
	int clientfd = socket(AF_INET, SOCK_STREAM, 0);
	//判断socket返回值
	if(-1 == clientfd)
	{
		//返回值为-1，代表创建软通道出错，打印出错原因并返回
		perror("socket error");
		return -1;
	}
	//创建软通道成功
	printf("socket ok----\r\n");
	//connect
	struct sockaddr_in serveraddr;
	//使用struct sockaddr_in结构体接受参数2的参数并强转为struct sockaddr结构体
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(8888);
	serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	int ret = connect(clientfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));
	//判断connect的返回值
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("connect error----\r\n");
		return -1;
	}
	//连接服务端成功
	printf("connect ok....\r\n");
	//创建数据缓冲区
	char buf[BUF_SIZE] = {0};
	while(1)
	{
		memset(buf, 0, BUF_SIZE );
		printf("please write:\r\n");
		//从标准输入端口输入数据，存储在buf里
		fgets(buf, BUF_SIZE, stdin);
		//send为发送数据
		ret = send(clientfd, buf, BUF_SIZE, 0);
		//返回值判断
		if(-1 == ret)
		{
			//失败返回原因，不做返回，接受服务端的数据
			perror("send error");
		}
		//清空接收数据的缓冲区
		memset(buf, 0, BUF_SIZE );
		//recv接收数据
		ret = recv(clientfd, buf, BUF_SIZE, 0);
		//返回值判断
		if(-1 == ret)
		{
			//失败返回原因并返回
			perror("recv error");
			return -1;
		}
		//成功打印接受的数据
		printf("recv data : %s\r\n", buf);
	}
	//关闭软通道描述符
	close(clientfd);
	return 0;	
}

在这里插入图片描述

思考：
多线程并发服务器的缺点：主线程退出了，子线程也会跟着退出。

select函数实现并发服务器

IO多路复用实现并发

思想分三步：

  1. 构建一张文件描述符集合表，表的大小1024bit，每一个bit位表示一个文件描述符所对应的IO通道是否有数据，若有数据，该bit位为1，若没有数据，该bit位为0.
  2. 使用**select()**函数监控指定范围的文件描述符对应的IO通道，是否有数据发生；如果有数据，返回有几路通道有数据同时更新相应bit位置为1，其他bit位置为0；否则，一直阻塞等待.
  3. 对文件描述符集合表的置位结果做出判断和响应。使用宏函数FD_ISSET(fd, &stFdr)；返回值如果是true，则要响应对应文件描述符的IO操作.如果没有被置位，则不处理。
    在这里插入图片描述
    访问顺序是：3435
    在这里插入图片描述
    server端：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#define BUF_SIZE 20
//tcp multiplexing
int main()
{
	//socket
	int serverfd = socket(AF_INET, SOCK_STREAM,0);
	//判断socket返回值
	if(-1 == serverfd)
	{
		perror("socket error");
		return -1;
	}
	//创建软通道成功
	printf("socket ok------\r\n");
	//bind
	struct sockaddr_in stserver;
	stserver.sin_family = AF_INET;
	stserver.sin_port = htons(8888);
	stserver.sin_addr.s_addr = inet_addr("127.0.0.1");
	int ret = bind(serverfd, (struct sockaddr*)&stserver, sizeof(struct sockaddr));
	//判断的返回值
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("bind error");
		return -1;
	}
	//绑定服务端主机成功
	printf("bind ok------\r\n");
	//listen
	ret = listen(serverfd, 5);
	//返回值判断
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("listen error");
		return -1;
	}
	//监听创建成功
	printf("listen ok------\r\n");
	//接受客户端的信息
	struct sockaddr_in stclient;
	//结构体大小
	socklen_t len = sizeof(struct sockaddr);
	//创建收发数据的缓冲区
	char buf[BUF_SIZE] = {0};

	//文件描述集合表
	fd_set stFdr;
	//清零
	FD_ZERO(&stFdr);

	FD_SET(serverfd, &stFdr);
    //用来存储最大描述符
	int max = serverfd;

	while(1)
	{
		//select
		//临时文件描述符表
		fd_set stFdrTmp = stFdr;
        //监控所有文件描述符
		ret = select(max+1, &stFdrTmp, NULL, NULL, NULL);
		if(ret < 0)
		{
			perror("select error");
			continue;
		}
		printf("select ok ret=%d\r\n", ret);

		//FD_ISSET

		int i = 0;
		for(; i < max + 1; i++)
		{
			if(FD_ISSET(i, &stFdrTmp))
			{
				if(i == serverfd)
				{
					int newfd = accept(serverfd, (struct sockaddr*)&stclient, &len);
					if(-1 == newfd)
					{
						perror("accept error");
						continue;
					}
					printf("accept ok newfd:%d\r\n", newfd);
                    //将新的描述符，加入到原始文件描述符集合中
					FD_SET(newfd, &stFdr);
                    //更新max
					if(max < newfd) max = newfd;
				}
				else
				{
					ret = recv(i, buf, BUF_SIZE ,0);
					if(ret > 0)
					{
                        printf("recv data;%s\r\n", buf);
						send(i, buf, BUF_SIZE ,0);
					}
					else
					{
						close(i);
						FD_CLR(i, &stFdr);
					}
				}
			}
		}
	}
	return 0;
}

client端：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define BUF_SIZE 20
//功能：TCPclient
int main()
{
	//socket
	int clientfd = socket(AF_INET, SOCK_STREAM, 0);
	//判断socket返回值
	if(-1 == clientfd)
	{
		//返回值为-1，代表创建软通道出错，打印出错原因并返回
		perror("socket error");
		return -1;
	}
	//创建软通道成功
	printf("socket ok----\r\n");
	//connect
	struct sockaddr_in serveraddr;
	//使用struct sockaddr_in结构体接受参数2的参数并强转为struct sockaddr结构体
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(8888);
	serveraddr.sin_addr.s_addr = inet_addr("192.168.15.71");
	int ret = connect(clientfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));
	//判断connect的返回值
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("connect error----\r\n");
		return -1;
	}
	//连接服务端成功
	printf("connect ok....\r\n");
	//创建数据缓冲区
	char buf[BUF_SIZE] = {0};
	while(1)
	{
		printf("please write:\r\n");
		//从标准输入端口输入数据，存储在buf里
		fgets(buf, BUF_SIZE, stdin);
		//send为发送数据
		ret = send(clientfd, buf, BUF_SIZE, 0);
		//返回值判断
		if(-1 == ret)
		{
			//失败返回原因，不做返回，接受服务端的数据
			perror("send error");
		}
		//清空接收数据的缓冲区
		memset(buf, 0, BUF_SIZE );
		//recv接收数据
		ret = recv(clientfd, buf, BUF_SIZE, 0);
		//返回值判断
		if(-1 == ret)
		{
			//失败返回原因并返回
			perror("recv error");
			return -1;
		}
		//成功打印接受的数据
		printf("recv data : %s\r\n", buf);
	}
	//关闭软通道描述符
	close(clientfd);
	return 0;	
}

在这里插入图片描述

little Y
关注
  • 27
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux 网络编程
qq_39855356的博客
09-16 4472
linux系统编程-网络编程
java网络编程
03-03
- **网络模型**：Java网络编程基于OSI七层模型和TCP/IP四层模型。理解这些模型有助于理解网络通信的基本原理。 - **IP地址与端口号**：IP地址用于标识网络上的设备，端口号则区分同一设备上的不同服务。 2. **...
Java 网络编程
热门推荐
ZaynFox的博客
05-30 6万+
网络编程 一、网络编程基础概念 首先理清一个概念：网络编程不等于网站编程，网络编程即使用套接字来达到进程间通信，现在一般称为TCP/IP编程。 计算机网络： 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大，功能强的网络系统，从而使众多的计算机可以方便的互相传递信息，共享硬件，软件，数据信息等资源。 计算机网络的主要功能： 资源共享 信息传输与集中处理 均衡负荷与分布处理 ...
网络编程详解
m0_37671741的博客
12-10 2797
网络编程中有两个主要的问题： （1）如何准确的定位网络上一台或多台主机（IP和端口号） （2）找到主机后如何可靠高效地进行数据传输（网络通信协议） 传输层协议 （1）TCP协议（传输控制协议，Transmission Control Protocol） 使用TCP协议前，须先建立TCP连接，形成数据通道 传输前，采用“三次握手”方式，是可靠的 TCP协议进行通信的两个应用进程：...
java——网络编程
Why_does_it_work的博客
06-24 4150
它的核心组件包括IoFilter、IoSession、IoHandler等，可以帮助开发人员构建可靠的、高效的网络应用程序。Spring Web是Spring框架中的一个模块，提供了一系列用于构建Web应用程序的工具和框架，包括MVC、REST等。它提供了丰富的API和插件，可以帮助开发人员实现高性能、可靠的Web应用程序。通过这些规则和标准，不同的计算机和设备可以相互通信，并保证数据的正确传输和接收。Java中的NIO编程是一种基于事件驱动的编程模式，相对于传统的IO编程，它具有更高的性能和扩展性。
linux网络编程
m0_72749070的博客
09-03 5448
自学笔记整理，如有不对，请指正
java网络编程第四版pdf
06-07
《Java网络编程（第四版）》是一本深入探讨Java在互联网环境下的编程技术的经典书籍。本书旨在帮助读者理解和掌握如何利用Java语言进行高效、安全的网络通信。书中内容覆盖了从基本的网络概念到复杂的多线程编程，是...
网络编程
01-06
网络编程 网络概念： 由点和线构成，表示诸多对象间的相互联系。 计算机网络： 为实现资源共享和信息传递，通过通信线路连接起来若干主机(Host)。 互联网： (Internet)点与点相连。 万维网： (WWW-World Wide Web)端...
c++网络编程
12-08
C++网络编程是计算机科学中的一个重要领域，它允许开发者创建能够通过互联网进行通信的应用程序。在C++中实现网络编程需要理解基本的网络概念、套接字编程、多线程和并发处理，以及如何处理异步事件。以下是对这些...
python socket 网络编程
01-19
在"python socket 网络编程"这个主题中，我们将深入探讨如何利用socket进行文件传输、命令行执行等核心功能。 一、Python Socket基础 Python中的socket模块源于C语言的socket接口，它提供了TCP/IP协议族的网络通信...
Linux网络工具“瑞士军刀“集合
分享不一样的技术，与你一起共同成长!
07-26 246
下面结合之前的一些使用经验为大家介绍一下一些经典应用场景下，这个网络命令工具如何使用的。例如怎么查看当前服务器监听哪些端口、连接目标主机端口情况如何?平常我们在进行Linux服务器相关运维的时候，总会遇到一些网络相关的问题。我们可以借助这些小巧、功能强悍的工具帮助我们排查问题、解决问题...
网络编程套接字socket
安权_code的博客
07-23 954
网络编程中的套接字（socket）是实现网络通信的关键，换句话来说，套接字像两个端点，而发送方与接收方就是通过这两个端点进行通信的，socket的意思是插座，表示插头和插座连接上后，即发送方和接收方连接上了，然后把电流通过插座流向插头对标发送方与接收方建立了链接。
S5730举例
最新发布
jjjxxxhhh123的博客
07-27 624
例子： 假设在校园网络中，某些交换机之间存在多个连接（可能是多个光纤），如果没有STP，这些多个连接可能导致数据包在网络中无限制地传输，形成网络风暴，导致整个网络瘫痪。PIM-SM通过仅在需要时在网络中传输组播数据包，减少网络带宽的占用，提高数据传输效率。[sysname-GigabitEthernet0/0/1] ospf cost 10 // 设置接口的OSPF成本，影响路径选择。综上所述，这些网络技术和配置在大学校园网络中起到关键作用，确保网络运行高效、安全和可靠，同时满足用户的多样化需求。
H3C与VPN高级应用（七）深入探讨H3C防火墙与VPN高级应用
洛秋的博客
07-23 1115
IPSec（Internet Protocol Security）是一种用于保护IP通信的协议，通过对数据包进行加密和认证来确保数据的机密性、完整性和真实性。IPSec VPN通常用于建立安全的远程连接，保护企业内部网络与远程办公或分支机构之间的数据通信。NAT（Network Address Translation）是一种将私有IP地址转换为公共IP地址的技术，通常用于多个设备共享一个公共IP地址访问互联网。NAT有助于节约公共IP地址，同时增强内部网络的安全性。
DNS域名管理系统、搭建DNS服务
十四的博客
07-23 932
DNS概述。
使用WebSocket协议调用群发方法将消息返回客户端页面
2302_79840586的博客
07-27 834
使用WebSocket协议调用群发方法将消息返回客户端页面
【计算机网络】OSPF单区域实验
m0_65787507的博客
07-26 759
DR和BDR是由同一网段中所有的路由器根据路由优先级和Router ID通过Hello报文选举出来的，只有优先级大于0的路由器才具有选举资格。进行DR/BDR选举时每台路由器将自己选出的DR写入Hello报文中，发给网段上的每台运行OSPF协议的路由器。如果DR或BDR失效，或者有新的路由器加入网络并希望成为DR或BDR，那么它们将参与新的选举过程。4：非DR路由器将自己的LSA发送给DR，然后DR将这些LSA泛洪到整个区域，使所有路由器获得一致的LSDB，从而确保区域内路由器都能计算出相同的最短路径树。
通信原理-思科实验五：家庭终端以太网接入Internet实验
sinat_39522506的博客
07-24 339
实验五 家庭终端以太网接入Internet实验。接着配置IP地址池和虚拟模板 开启宽带拨号。1.按照上图选择对应的设备，并连接起来。5.为路由器R1配置静态路由项。7.完成终端PC2 IP配置。
应用层自定义协议以及序列化和反序列化
Xpccccc的博客
07-24 1003
应用层自定义协议以及序列化和反序列化
Java网络编程第四版精华
"Java网络编程第四版" 《Java网络编程第四版》是由Elliotte Rusty Harold编写的关于Java网络编程的权威指南。这本书深入探讨了Java在构建网络应用程序时的各种技术和概念，旨在帮助读者掌握利用Java进行网络通信的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值