5月21日 网络编程day4

1.项目中如何实现TCP的并发？

答：采用多进程、多线程或者IO多路复用进行通信。

2.TCP通信过程中的三次握手？

答：①：客户端发送SYN包（SYN=1，seq=0）给服务器，并进入SYN_SENT状态，等待服务器返回确认包。
       ②：服务器接受SYN包，确定后发送ACK包（ACK=1，ack=1），接着发送SYN（SYN=1，seq=0），并进入SYN_RCVD状态。
       ③：客户端接收到服务器的SYN包和ACK包之后进入establish状态，同时向服务器发送ACK包 （ACK=1，ack=1），握手完毕，服务器端也进入establish状态。

3.四次挥手的过程？

答：①：主动关闭方发送FIN包（FIN=1，seq=u）给被动方，进入FIN_WAIT_1状态。
       ②：被动方接收到FIN包之后，发送一个ACK包（ACK=1，ack=u+1），进入CLOKSE_WAIT状态。主动方接收ACK包后进入FIN_WAIT_2状态。如果数据未发送完，则继续发送至结束。
       ③：被动方发送一个FIN包（FIN=1，seq=w），进入LAST_ACK状态。
       ④：主动关闭方收到FIN包,回复一个ACK包（ACK=1，ack=w+1）。被动关闭方收到主动关闭方的ACK后关闭连接。

4.TCP/IP协议分几层？Tcp/ip是哪一层的？

答：四层。应用层、传输层、网络层、以太网层。tcp在传输层、ip在网络层。

5.Udp为什么会发生丢包？如何处理丢包现象？丢包发生在哪一层，为什么？

答：udp是面向无连接的、不可靠的的传输协议，网络拥塞、传输距离长、网络配置错误、软硬件出现问题等原因都是导致丢包现象。冗余传输、选择性重传、改善网络、流量控制、使用tcp协议都可以解决丢包现象。丢包发生在网络层或传输层。网络层中可能是路由器或交换机中数据包丢失、传输层中可能是传输过程中数据包丢失。

6.TCP是同步还是异步，同步异步如何理解？

答：TCP是同步的。同步是任务发生阻塞，需要等待其他任务接收才会继续执行；异步是任务之间不会相互影响。

7.什么是tcp粘包现象？如何解决？

答：由于TCP是基于流的数据传输，没有固定的消息边界，发送数据过大时候，接收方可能会将多个小的包组合成一个大的包。可以设置固定的消息大小，或者封装消息。

8.组播和广播的区别？

答：1.广播的范围是同一个局域网下的所有主机，组播是一组网络下的主机。

        2.广播是网络号+255，组播是D类地址。

        3.广播可能会出现阻塞现象。组播是只发送给特定的主机，减少了不必要的网络阻塞。

9.阻塞Io和非阻塞IO的区别？

答：1.阻塞IO：调用线程或进程在IO操作完成前无法继续执行其他任务

        2.非阻塞IO：有一个IO操作无法立即完成时，调用该操作的线程或进程不阻塞，而是返回一个错误

10,。并发和并行的区别？

答：并发是单核处理器对应多个进程，并行是多核处理器对应多个进程。

//TFTP通信
#include <myhead.h>
#define SER_PORT 69
char serip[128];
//下载
int download(int sfd)
{ 	//bind ser
	struct sockaddr_in sin;
	sin.sin_family=AF_INET;
	sin.sin_port=htons(SER_PORT);
	sin.sin_addr.s_addr=inet_addr(serip);
	socklen_t socklen=sizeof(sin);
	
	//终端获取文件名
	char name[128]={0};
	printf("请输入文件名>>>>>");
	fgets(name,sizeof(name),stdin);
	name[strlen(name)-1]=0;

	//填充读写请求
	char data[516]={0};
	short *p1=(short *)data;
	*p1=htons(1);//1为RD，2为WR
	char *p2=data+2;
	strcpy(p2,name);
	char *p4=p2+strlen(p2)+1;
	strcpy(p4,"octet");
	int size=4+strlen(name)+strlen("octet");

	//发送请求包
	if(sendto(sfd,data,size,0,(struct sockaddr*)&sin,socklen)==-1)
	{ 	perror("sendto");return -1;}
	printf("发送下载请求成功\n");

	//接受数据包
	int fd=-1;
	short hl=0;
	while(1)
	{ 	memset(data,0,sizeof(data));
		int res=recvfrom(sfd,data,sizeof(data),0,(struct sockaddr*)&sin,&socklen);
		if(res==-1){perror("recvfrom");return -1;}

		//解析数据包
		short data1=ntohs(*(short *)data);
		short data2=ntohs(*((short *)(data+2)));

		//判断数据包
		if(data1==3)
		{ 	if(data2==++hl)
			{ 	//无丢包
				if(data2==1)
				{ 	fd=open(name,O_WRONLY|O_CREAT|O_TRUNC,0664);
					if(fd<0){perror("open");return -1;}
				}
				if(write(fd,data+4,res-4)==-1){perror("write");return -1;}
				
				//填写ACK报文
				char ack[4]={0};
				short *p1=(short *)ack;
				*p1=htons(4);
				*(p1+1)=htons(data2);

				//发送ACK报文
				if(sendto(sfd,ack,sizeof(ack),0,(struct sockaddr*)&sin,sizeof(sin))==-1)
				{ 	perror("sendto");return -1;}

				//数据接收完毕
				if(res<516){printf("%s 下载完成\n",name);break;}
			}
			else
			{ 	//填写ACK报文
				char ack[4]={0};
				short *p1=(short *)ack;
				*p1=htons(4);
				*(p1+1)=htons(data2);
				
				//发送ACK报文
				if(sendto(sfd,ack,sizeof(ack),0,(struct sockaddr*)&sin,sizeof(sin))==-1)
				{ 	perror("sendto");return -1;}
			}
		}

		//接收错误包
		else if(data1==5)
		{ 	short err;
			err=ntohs(*(data+2));
			printf("err=%d\n",err);
			break;
		}
	}
	close(fd);
}
//上传
int upload(int sfd)
{ 	//服务器的信息
	struct sockaddr_in sin;
	sin.sin_family=AF_INET;
	sin.sin_port=htons(SER_PORT);
	sin.sin_addr.s_addr=inet_addr(serip);
	socklen_t socklen=sizeof(sin);

	//获取终端名
	char name[128]={0};
	fgets(name,sizeof(name),stdin);
	name[strlen(name)-1]=0;

	//填写请求报文
	char data[516]={0};
	short *p1=(short *)data;
	*p1=htons(2);//1为RD，2为WR
	char *p2=data+2;
	strcpy(p2,name);
	char *p4=p2+strlen(p2)+1;
	strcpy(p4,"octet");
	int size=4+strlen(name)+strlen("octet");

	//发送请求包
	if(sendto(sfd,data,size,0,(struct sockaddr*)&sin,socklen)==-1)
	{ 	perror("sendto");return -1;}
	printf("发送上传请求成功\n");

	//读取服务器应答
	char ack[128]={0};
	int res=recvfrom(sfd,ack,sizeof(ack),0,(struct sockaddr*)&sin,&socklen);
	if(res<0){perror("recvfrom");return -1;}

	//解析ACK请求应答包
	short data1=ntohs(*(short *)ack);
	short data2=ntohs(*((short *)(ack+2)));

	//不允许上传
	if(data2!=0){return -1;}

	//允许上传
	int fd=-1;
	short hl=0;

	fd=open(name,O_RDONLY);
	if(fd<0){perror("open");return -1;}
	while(1)
	{ 	memset(data,0,sizeof(data));
		short *p1=(short *)data;
		*p1=htons(3);
		*(p1+1)=htons(++hl);

		//读取文件
		int res=read(fd,data+4,512);
		if(res<0){perror("read");return -1;}

		//给服务器发送数据包
		if(sendto(sfd,data,res+4,0,(struct sockaddr*)&sin,sizeof(sin))<0)
		{perror("sendto");return -1;}
		
		//上传结束
		if(res==0){printf("%s 上传成功\n",name);break;}
		
		//读取服务器应答
		memset(ack,0,sizeof(ack));
		while(1)
		{ 	res=recvfrom(sfd,ack,sizeof(ack),0,(struct sockaddr*)&sin,&socklen);
			if(res<0){perror("recvfrom");return -1;}

			//解析ACK包
			short data1=ntohs(*(short *)ack);
			short data2=ntohs(*((short *)(ack+2)));

			if(data1=4)
			{ 	//判断丢包清空
				//无丢包
				if(data2=hl){break;}

				//丢包
				if(sendto(sfd,data,sizeof(data),0,(struct sockaddr*)&sin,sizeof(sin))==-1);
				{perror("sendto");return -1;}
			}
			else if(data1==5)
			{ 	printf("err=%d\n",data2);
				return -1;
			}
		}
	}
	close(fd);
}
int main(int argc, const char *argv[])
{
	//socket
	int sfd=socket(AF_INET,SOCK_DGRAM,0);

	//终端输入连接服务端IP
	printf("请输入服务器IP:\n");
	fgets(serip,sizeof(serip),stdin);
	serip[strlen(serip)-1]=0;

	//循环操作
	while(1)
	{ 	printf("*******1.下载*******\n");
	 	printf("*******2.上传*******\n");
	 	printf("*******3.退出*******\n");
		printf("请选择:");
		int cho;
		scanf("%d",&cho);
		while(getchar()!=10);
		switch(cho)
		{ 	case 1:download(sfd);break;
		 	case 2:upload(sfd);break;
		 	case 3:return -1;
			default:printf("输入错误\n");return -1;
		}
	}
	return 0;
}

//广播接收端
#include <myhead.h>
int main(int argc, const char *argv[])
{
	// socket
	int rfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (rfd == -1)
	{
		perror("socket");
		return -1;
	}

	// bind
	struct sockaddr_in rin;
	rin.sin_family = AF_INET;
	rin.sin_port = htons(6666);
	rin.sin_addr.s_addr = inet_addr("192.168.125.255");

	if (bind(rfd, (struct sockaddr *)&rin, sizeof(rin)) == -1)
	{
		perror("bind");
		return -1;
	}

	// recvfrom
	char rbuf[128];
	while (1)
	{
		bzero(rbuf, sizeof(rbuf));
		recv(rfd, rbuf, sizeof(rbuf), 0);
		printf("广播消息为：%s\n", rbuf);

		//	if(strcmp(rbuf,"over")==0)
		//	{printf("广播结束\n");break;}
	}
	close(rfd);
	return 0;
}

#include <myhead.h>
#define IP "192.168.125.255"
#define PORT 6789
int main(int argc, const char *argv[])
{    
    //广播发送端
	//socket
	int sfd=socket(AF_INET,SOCK_DGRAM,0);
	if(sfd==-1)
	{perror("socket");return -1;}
	
	//setsockopt
	int broadcast=1;
	if(setsockopt(sfd,SOL_SOCKET\
				,SO_BROADCAST,&broadcast,\
				sizeof(broadcast))==-1)
	{perror("broadcast");return -1;}
 
	//recvfrom
	struct sockaddr_in rin;
	rin.sin_family=AF_INET;
	rin.sin_port=htons(PORT);
	rin.sin_addr.s_addr=inet_addr(IP);
 
	char sbuf[128];
	while(1)
	{ 	printf("请输入>>>");
		fgets(sbuf,sizeof(sbuf),stdin);
		sbuf[strlen(sbuf)-1]=0;
 
		sendto(sfd,sbuf,strlen(sbuf),0,\
				(struct sockaddr*)&rin,sizeof(rin));
		printf("发送成功\n");
	}
 
	//close
	close(sfd);
	return 0;
}
#include <myhead.h>
#define IP "224.1.1.1"
#define H_IP "192.160.125.220"
int main(int argc, const char *argv[])
{
    //组播接收端
	//socket
	int rfd=socket(AF_INET,SOCK_DGRAM,0);
	if(rfd==-1)
	{perror("socket");return -1;}
 
	//setsockopt
	struct ip_mreqn imq;
	imq.imr_multiaddr.s_addr=inet_addr(IP);
	imq.imr_address.s_addr=inet_addr(H_IP);
	imq.imr_ifindex=2;
	if(setsockopt(rfd,IPPROTO_IP,IP_ADD_MEMBERSHIP,&imq,sizeof(imq))==-1)
	{perror("setsockopt");return -1;}
	printf("加入多播组成功\n");
 
	//bind
	struct sockaddr_in rin;
	rin.sin_family=AF_INET;
	rin.sin_port=htons(5555);
	rin.sin_addr.s_addr=inet_addr(IP);
 
	if(bind(rfd,(struct sockaddr*)&rin,sizeof(rin))==-1)
	{perror("bind");return -1;}
 
	//recvfrom
	char rbuf[128];
	while(1)
	{ 	bzero(rbuf,sizeof(rbuf));
		recvfrom(rfd,rbuf,sizeof(rbuf),0,NULL,NULL);
		printf("收到组播消息：%s\n",rbuf);
	}
	//close
	close(rfd);
	return 0;
}
#include <myhead.h>
#define IP "224.1.1.1"
#define PORT 5555
int main(int argc, const char *argv[])
{    
    //组播发送端
	//socket
	int sfd=socket(AF_INET,SOCK_DGRAM,0);
	if(sfd==-1)
	{perror("socket");return -1;}
	
	//recvfrom
	struct sockaddr_in rin;
	rin.sin_family=AF_INET;
	rin.sin_port=htons(PORT);
	rin.sin_addr.s_addr=inet_addr(IP);
 
	char sbuf[128];
	while(1)
	{ 	printf("请输入>>>");
		fgets(sbuf,sizeof(sbuf),stdin);
		sbuf[strlen(sbuf)-1]=0;
 
		sendto(sfd,sbuf,strlen(sbuf),0,\
				(struct sockaddr*)&rin,sizeof(rin));
		printf("发送成功\n");
	}
 
	//close
	close(sfd);
	return 0;
}
#include<myhead.h>
//流式域套接字服务端
 
int main(int argc, const char *argv[])
{
    //1、创建套节字：用于接收客户端链接请求的
    int sfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("socket success sfd = %d\n", sfd);     //3
 
    //判断要绑定的套接字文件是否存在，如果存在，需要将其删除
    if(access("./unix", F_OK) == 0)
    {
        //说明文件存在，需要将其删除
        if(unlink("./unix") != 0)
        {
            perror("unlink error");
            return -1;
        }
    }
 
    //2、绑定套接字文件
    //2.1 填充地址信息结构体
    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;    //通信域
    strcpy(sun.sun_path , "./unix");    //套接字文件
 
 
    //2.2 绑定工作
    if( bind(sfd, (struct sockaddr*)&sun, sizeof(sun)) ==-1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");
 
 
    //3、讲套节字设置成被动监听状态
    if( listen(sfd, 128) == -1)
    {
        perror("listen error");
        return -1;
    }
    printf("listen success\n");
 
    //4、阻塞等待客户端连接请求
    //定义地址信息结构体变量用于接受客户端的地址信息
    struct sockaddr_un cun;
    socklen_t socklen = sizeof(cun);     //接受地址信息的长度
    
    int newfd = accept(sfd, (struct sockaddr*)&cun, &socklen);
    if(newfd == -1)
    {
        perror("accept error");
        return -1;
    }
 
    printf("[%s]:已连接, newfd = %d\n", cun.sun_path,newfd);    //4
 
    //5、数据通信
    char rbuf[128] = "";       //用于接受消息
    while(1)
    {
        bzero(rbuf, sizeof(rbuf));    //清空容器
        //从套接字文件中读取消息
        //int ret = read(newfd, rbuf, sizeof(rbuf));
        int ret = recv(newfd, rbuf, sizeof(rbuf), 0);
        if(ret == 0)
        {
            printf("客户端已下线\n");
            break;
        }
        printf("[%s]: %s\n", cun.sun_path ,rbuf );
 
        //将字符串加个笑脸回回去
        strcat(rbuf, "*_*");
        //write(newfd, rbuf, strlen(rbuf));
        send(newfd, rbuf, strlen(rbuf), 0);
        printf("发送成功\n");
 
    }
 
    //6、关闭套接字
    close(newfd);
    close(sfd);
 
    return 0;
}
#include<myhead.h>
//流式域套接字客户端
int main(int argc, const char *argv[])
{
    //1、创建用于通信的套接字文件描述符
    int cfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if(cfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("socket success cfd = %d\n", cfd);           //3
 
    //判断要绑定的套接字文件是否存在，如果存在，需要将其删除
    if(access("./linux", F_OK) == 0)
    {
        //说明文件存在，需要将其删除
        if(unlink("./linux") != 0)
        {
            perror("unlink error");
            return -1;
        }
    }
 
    //2、绑定套接字文件
    //2.1 填充地址信息结构体
    struct sockaddr_un cun;
    cun.sun_family = AF_UNIX;     //协议族
    strcpy(cun.sun_path, "./linux");    //客户端的套接字文件
 
    //2.2 绑定工作
    if(bind(cfd, (struct sockaddr*)&cun, sizeof(cun)) == -1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");
    
 
    
 
    //3、连接服务器
    //3.1 填充要连接的服务器地址信息结构体
    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;   //协议族
    strcpy(sun.sun_path, "./unix");    //服务器绑定的套接字文件
 
    //3.2 连接服务器
    if(connect(cfd, (struct sockaddr*)&sun, sizeof(sun))==-1)
    {
        perror("connect error");
        return -1;
    }
    printf("connect success\n");
 
    //4、数据收发
    char wbuf[128] = "";
    while(1)
    {
        //从终端获取数据
        printf("请输入>>>>");
        fgets(wbuf, sizeof(wbuf), stdin);
        wbuf[strlen(wbuf)-1] = '\0';
        if(strcmp(wbuf, "quit") == 0)
        {
            break;
        }
 
        //讲数据发送给服务器
        //write(cfd, wbuf, strlen(wbuf));
        send(cfd, wbuf, strlen(wbuf), 0);
 
        //接收服务器发来的消息
        bzero(wbuf, sizeof(wbuf));
        //read(cfd, wbuf, sizeof(wbuf));
        recv(cfd, wbuf, sizeof(wbuf), 0);
        printf("收到服务器的消息为：%s\n", wbuf);
    }
 
    //5、关闭套接字
    close(cfd);
    
 
 
 
 
    return 0;
}
#include<myhead.h>
 
//报式域套接字服务端
int main(int argc, const char *argv[])
{
    //1、创建用于通信的套接字文件描述符
    int sfd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("socket success sfd = %d\n", sfd);         //3
 
    //判断要绑定的套接字文件是否存在，如果存在，需要将其删除
    if(access("./unix", F_OK) == 0)
    {
        //说明文件存在，需要将其删除
        if(unlink("./unix") != 0)
        {
            perror("unlink error");
            return -1;
        }
    }
    //2、绑定IP地址和端口号
    //2.1 填充地址信息结构体
    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;       //协议族
    strcpy(sun.sun_path, "./unix");   //服务器的套接字文件
 
    //2.2 绑定工作
    if(bind(sfd, (struct sockaddr*)&sun, sizeof(sun)) == -1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");
 
    //3、数据的收发
    //定义变量接收客户端地址信息结构体
    struct sockaddr_un cun;
    socklen_t socklen = sizeof(cun);
 
    char rbuf[128] = "";
    while(1)
    {
        bzero(rbuf, sizeof(rbuf));
 
        //读取套接字中的数据
        recvfrom(sfd, rbuf, sizeof(rbuf), 0, (struct sockaddr*)&cun, &socklen);
        printf("[%s]：%s\n",cun.sun_path, rbuf);
 
        //加个笑脸将消息回回去
        strcat(rbuf, "*_*");
        if(sendto(sfd, rbuf, strlen(rbuf), 0, (struct sockaddr*)&cun, sizeof(cun)) ==-1)
        {
            perror("write error");
            return -1;
        }
        printf("发送成功\n");
 
    }
 
    //4、关闭套接字
    close(sfd);
 
    return 0;
}
#include<myhead.h>
//报式域套接字客户端
int main(int argc, const char *argv[])
{
    //1、创建用于通信的套接字文件描述符
    int cfd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if(cfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("socket success sfd = %d\n", cfd);         //3
 
    //判断要绑定的套接字文件是否存在，如果存在，需要将其删除
    if(access("./linux", F_OK) == 0)
    {
        //说明文件存在，需要将其删除
        if(unlink("./linux") != 0)
        {
            perror("unlink error");
            return -1;
        }
    }
 
    //2、绑定套接字文件
    //2.1 填充地址信息结构体
    struct sockaddr_un cun;
    cun.sun_family = AF_UNIX;       //协议族
    strcpy(cun.sun_path, "./linux");  //客户端套接字文件
 
    //2.2 绑定工作
    if(bind(cfd, (struct sockaddr*)&cun, sizeof(cun)) == -1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");
    
    
 
 
    //3、数据的收发
    //填充服务器的地址信息结构体
    struct sockaddr_un sun;
    sun.sun_family = AF_UNIX;
    strcpy(sun.sun_path, "./unix");
 
    char wbuf[128] = "";
    while(1)
    {
        //从终端输入数据
        printf("请输入>>>");
        fgets(wbuf, sizeof(wbuf), stdin);
        wbuf[strlen(wbuf)-1] = 0;
 
        //发送给服务器
        sendto(cfd, wbuf, strlen(wbuf), 0, (struct sockaddr*)&sun, sizeof(sun));
        printf("发送成功\n");
 
        //接受服务器回过来的消息
        recvfrom(cfd, wbuf, sizeof(wbuf), 0, NULL, NULL);
        printf("收到服务器消息为：%s\n", wbuf);
    }
 
    //4、关闭套接字
    close(cfd);
 
    return 0;
}

 

 

 

 

 

 

 

 

 

 

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【大模型】 基于AI和全球化进程的权衡：开源大模型与闭源大模型

【大模型】 基于AI和全球化进程的权衡：开源大模型与闭源大模型

【大模型】 基于AI和全球化进程的权衡&#xff1a;开源大模型与闭源大模型 前言 实际上关于开源or闭源&#xff0c;一直以来都是颇有争议的话题&#xff0c;人们争执于数据的隐私性和共享性&#xff0c;到底哪一方能获得的收益更大。而对于开源与闭源哪个更好实际上也就是说是…
阅读更多...
YoloV9实战与改进——专栏目录

YoloV9实战与改进——专栏目录

摘要 &#x1f525;&#x1f680;本专栏教你如何嗨翻Yolov9&#xff01;&#x1f680;&#x1f525; &#x1f680;炸裂升级&#xff1a;嗨&#xff0c;小伙伴们&#xff01;这里有一波Yolov9的升级大招&#xff0c;带你领略最新论文的精华&#xff01;&#x1f4a5; 什么注意…
阅读更多...
ue引擎游戏开发笔记（47）——设置状态机解决跳跃问题

ue引擎游戏开发笔记（47）——设置状态机解决跳跃问题

1.问题分析&#xff1a; 目前当角色起跳时&#xff0c;只是简单的上下移动&#xff0c;空中仍然保持行走动作&#xff0c;并没有设置跳跃动作&#xff0c;因此&#xff0c;给角色设置新的跳跃动作&#xff0c;并优化新的动作动画。 2.操作实现&#xff1a; 1.实现跳跃不复杂&…
阅读更多...
得物小程序逆向+qt可视化（不含sku）

得物小程序逆向+qt可视化（不含sku）

声明 本文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff0c;抓包内容、敏感网址、数据接口等均已做脱敏处理&#xff0c;严禁用于商业用途和非法用途&#xff0c;否则由此产生的一切后果均与作者无关&#xff01;wx a15018601872 本文章未…
阅读更多...
loguru和print输出顺序乱序

loguru和print输出顺序乱序

执行代码&#xff1a; from loguru import logger for i in range(1000):print(i)logger.info(i)执行效果&#xff1a; 0 1 2 3 4 2024-05-25 09:52:01.974 | INFO | __main__:<module>:6 - 0 2024-05-25 09:52:01.974 | INFO | __main__:<module>:6 - 1…
阅读更多...
Java面试八股之可重入锁ReentrantLock是怎么实现可重入的

Java面试八股之可重入锁ReentrantLock是怎么实现可重入的

可重入锁ReentrantLock是怎么实现可重入的 ReentrantLock实现可重入性的机制主要依赖于以下几个核心组件和步骤&#xff1a; 状态计数器&#xff1a;ReentrantLock内部维护一个名为state的整型变量作为状态计数器&#xff0c;这个计数器不仅用来记录锁是否被持有&#xff0c;…
阅读更多...
【算法例题】n元钱买n只鸡

【算法例题】n元钱买n只鸡

题目描述&#xff1a;公鸡5元1只&#xff0c;母鸡3元1只&#xff0c;小鸡1元3只&#xff0c;问&#xff1a;n元钱买n只鸡&#xff0c;怎么买&#xff1f; 解题思路&#xff1a;这题要用枚举算法&#xff0c;枚举鸡的数量&#xff0c;代码如下&#xff1a; ​#include <bit…
阅读更多...
UE5 像素流与web 交互

UE5 像素流与web 交互

总结下虚幻与网页的交互&#xff0c;这里将ue5 与js 交互传递参数记录下&#xff0c;其它的博主写的就是缺胳膊少腿的要么就是封闭收费&#xff0c;这个是在官方可以查询到。这里记录下&#xff1a; 点个关注不迷路&#xff1a; 具体的使用如下&#xff1a; 在你的游戏玩家类…
阅读更多...
想要修改Excel表格内容，怎么移除编辑权限？

想要修改Excel表格内容，怎么移除编辑权限？

在使用Excel进行数据处理和管理时&#xff0c;我们经常会遇到需要保护工作表以防止误操作的情况。有时可能碰到“被保护单元格不支持此功能”的提示&#xff0c;本文将详细介绍这个问题的解决方案&#xff0c;帮助你取消单元格保护&#xff0c;使用所需的功能。 一、取消单元格…
阅读更多...
01_Spark概述

01_Spark概述

文章目录 1.Spark概述Spark就是基于MR开发分布式计算分布式存储分布式传输集群中心化集群去中心化Spark集群中心化框架与系统引擎Driver 2.Spark核心模块3.spark和MR开发语言上处理方式Spark能否代替MR&#xff1f; 4.Spark运行模式部署Spark部署方式local模式 1.Spark概述 Sp…
阅读更多...
汇编实现的操作系统

汇编实现的操作系统

掌握X86汇编语言和GDB程序调试工具对于程序员来说是非常重要的_gdb 查看x86汇编-CSDN博客 掌握编译器和虚拟机的开发有哪些方面的好处-CSDN博客 Ville Mikael Turjanmaan开发的一个操作系统MenuetOS可运行在IA-32, x86-64平台上&#xff0c;完全用 64 位汇编语言编写。功能包…
阅读更多...
【vue-1】vue入门—创建一个vue应用

【vue-1】vue入门—创建一个vue应用

最近在闲暇时间想学习一下前端框架vue&#xff0c;主要参考以下两个学习资料。 官网 快速上手 | Vue.js b站学习视频 2.创建一个Vue3应用_哔哩哔哩_bilibili 一、创建一个vue3应用 <!DOCTYPE html> <html lang"en"> <head><meta charset&q…
阅读更多...
Unreal Engine5 Landscape地形材质无法显示加载

Unreal Engine5 Landscape地形材质无法显示加载

UE5系列文章目录 文章目录 UE5系列文章目录前言一、解决办法 前言 在使用ue5做地形编辑的时候&#xff0c;明明刚才就保存的Landscape地形完全消失不见&#xff0c;或者是地形的材质不见了。重新打开UE5发现有时候能解决&#xff0c;但大多数时候还是没有解决&#xff0c;我下…
阅读更多...
AI应用案例：服务器智能分析管理系统

AI应用案例：服务器智能分析管理系统

服务器硬件配置、性能状态、所运行的应用系统等信息分散于多个不同的信息管理系统。人为查询判断现有的服务器资源是否满足用户需求&#xff0c;且需结合资产管理系统与Maximo基础资源、性能监控、运维管理等各个系统互不关联&#xff0c;数据分散不能为运维管理提供完整一致的…
阅读更多...
探索AI写作工具：五款推荐

探索AI写作工具：五款推荐

在现实生活中&#xff0c;除了专业的文字工作者&#xff0c;各行各业都避免不了需要写一些东西&#xff0c;比如策划案、论文、公文、讲话稿、总结计划……等等。而随着科技的进步&#xff0c;数字化时代的深入发展&#xff0c;AI已经成为日常工作中必不可少的工具了&#xff0…
阅读更多...
特征融合篇 | YOLOv8改进之利用新的空间金字塔池化FocalModulation取代SPPF

特征融合篇 | YOLOv8改进之利用新的空间金字塔池化FocalModulation取代SPPF

前言：Hello大家好，我是小哥谈。Focal Modulation Networks（FocalNets）的基本原理是替换自注意力（Self-Attention）模块，使用焦点调制（focal modulation）机制来捕捉图像中的长距离依赖和上下文信息。本文所做的改进是将新的空间金字塔池化FocalModulation取代SPPF模块。…
阅读更多...
AWS Elastic Beanstalk 监控可观测最佳实践

AWS Elastic Beanstalk 监控可观测最佳实践

一、概述 Amazon Web Services (AWS) 包含一百多种服务&#xff0c;每项服务都针对一个功能领域。服务的多样性可让您灵活地管理 AWS 基础设施&#xff0c;然而&#xff0c;判断应使用哪些服务以及如何进行预配置可能会非常困难。借助 Elastic Beanstalk&#xff0c;可以在 AW…
阅读更多...
LLM大模型的7种推理框架分析

LLM大模型的7种推理框架分析

LLM的7种推理框架 Hugging Face的transformers 这是一个Python库&#xff0c;可以简化本地运行LLM的过程。 Transformers的优点&#xff1a; 自动模型下载提供代码片段非常适合实验和学习 Transformers的缺点&#xff1a; 需要对ML和NLP有深入了解需要编码和配置技能 2.L…
阅读更多...
探寻最强性能云电脑：ToDesk云电脑、无影云、网易云游戏、易腾云横测大比拼

探寻最强性能云电脑：ToDesk云电脑、无影云、网易云游戏、易腾云横测大比拼

大家好&#xff0c;我是herosunly。985院校硕士毕业&#xff0c;现担任算法研究员一职&#xff0c;热衷于机器学习算法研究与应用。曾获得阿里云天池比赛第一名&#xff0c;CCF比赛第二名&#xff0c;科大讯飞比赛第三名。拥有多项发明专利。对机器学习和深度学习拥有自己独到的…
阅读更多...
Linux基础（二）：环境搭建

Linux基础（二）：环境搭建

本文准备从0开始&#xff0c;一步步搭建一套属于自己的Linux系统环境&#xff0c;这将是后续学Linux、用Linux、Linux环境编程、应用和项目部署、工具实验等一系列学习和实践的基石&#xff0c;希望对小伙伴们有帮助。提前备好Linux编程实验环境非常重要&#xff0c;建议人手一…
阅读更多...
最新文章

Copyright @ 2022~2023