#1024程序员节
#三次握手四次挥手#四次挥手#udp#recvfrom#sendto#服务器模型#客户端模型#Linux IO模型#阻塞式IO#非阻塞IO#设置非阻塞的方式
目录
[1. 通信流程](#1. 通信流程)
[2. 函数接口](#2. 函数接口)
[【3】Linux IO模型](#【3】Linux IO模型)
[1. 阻塞式IO：最常见、效率低、不耗费cpu](#1. 阻塞式IO：最常见、效率低、不耗费cpu)
[2. 非阻塞IO：轮询、耗费CPU，可以处理多路IO](#2. 非阻塞IO：轮询、耗费CPU，可以处理多路IO)
[1. 通过函数自带参数设置](#1. 通过函数自带参数设置)
[2. 通过设置文件描述符的属性。把文件描述符的属性设置为非阻塞](#2. 通过设置文件描述符的属性。把文件描述符的属性设置为非阻塞)
[3. 信号驱动IO/异步IO：异步通知方式，需要底层驱动的支持（了解）](#3. 信号驱动IO/异步IO：异步通知方式，需要底层驱动的支持（了解）)
【0】复习
tcp：服务器、客户端
网络模型：OSI:应、表、会、传、网、数、物 TCP/IP：应、传、网、物
TCP：全双工、高可靠，连接
UDP：全双工、无连接、不可靠
wireshark
三次握手：SYN SYN_SEND SYN+ACK SYN_RECV ACK ESTABLISHED
【1】三次握手四次挥手
四次挥手
四次挥手既可以由客户端发起，也可以由服务器发起
TCP连接终止需四个分节。
类比挂电话的过程：
第一次挥手：我说完了，我要挂了
第二次挥手：好的，我知道了，但是你先别急，等我把话说完
第三次挥手：好了，我说完了，咱们可以挂电话了
第四次挥手：好的，挂了吧
第一次挥手：某个应用进程首先调用close，我们称这一端执行主动关闭。这一端的TCP于是发送一个FIN分节，表示数据发送完毕。
第二次挥手：接收到FIN的另一端执行被动关闭（passive close）。这个FIN由TCP确认。它的接收也作为文件结束符传递给接收端应用进程（放在已排队等候应用进程接收到任何其他数据之后）
第三次挥手：一段时间后，接收到文件结束符的应用进程将调用close关闭它的套接口。这导致它的TCP也发送一个FIN。
第四次挥手：接收到这个FIN的原发送端TCP对它进行确认。
【2】udp
1. 通信流程
服务器----------------------------------------------------------------------------》短信的接收方
- 创建数据报套接字（socket）------------------》有手机
- 指定网络信息--------------------------------------》有号码
- 绑定套接字（bind）------------------------------》绑定手机
- 接收、发送消息（recvfrom sendto）-------》收短信
- 关闭套接字（close）----------------------------》接收完毕
客户端---------------------------------------------------------------------------》短信的发送方
- 创建数据报套接字（socket）------------------》有手机
- 指定网络信息--------------------------------------》有对方号码
- 接收、发送消息（recvfrom sendto）-------》发短信
- 关闭套接字（close）----------------------------》发送完毕
2. 函数接口
1.recvfrom
cpp
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen);
功能：接收数据
参数：
sockfd：套接字描述符
buf:接收缓存区的首地址
len：接收缓存区的大小
flags：0
src_addr:发送端的网络信息结构体的指针
addrlen：发送端的网络信息结构体的大小的指针
返回值：
成功接收的字节个数
失败：-1
0:客户端退出2.sendto
cpp
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,const struct sockaddr *dest_addr, socklen_t addrlen);
功能：发送数据
参数：
sockfd：套接字描述符
buf:发送缓存区的首地址
len：发送缓存区的大小
flags：0
src_addr:接收端的网络信息结构体的指针
addrlen：接收端的网络信息结构体的大小
返回值：
成功发送的字节个数
失败：-1服务器模型
cpp
#include <stdio.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
char buf[128] = {0};
int ret;
// 1.创建数据报套接字（socket）------------------》有手机
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
perror("socket err");
return -1;
}
printf("sockfd:%d\n", sockfd);
// 2.指定网络信息--------------------------------------》有号码
struct sockaddr_in saddr, caddr;
saddr.sin_family = AF_I
saddr.sin_port = htons(atoi(argv[1]));
saddr.sin_addr.s_addr = INADDR_ANY;
int len = sizeof(caddr);
// 3.绑定套接字（bind）------------------------------》绑定手机
if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
{
perror("bind err");
return -1;
}
printf("bind okk\n");
// 4.接收、发送消息（recvfrom sendto）-------》收短信
while (1)
{
// 最后两个参数存放:发送消息的人的信息
ret = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&caddr, &len);
if (ret < 0)
{
perror("recvfrom err");
return -1;
}
else
{
printf("ip:%s port:%d buf:%s\n",inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port), buf);
memset(buf, 0, sizeof(buf));
}
}
// 5.关闭套接字（close）----------------------------》接收完毕
close(sockfd);
return 0;
}客户端模型
cpp
#include <stdio.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
char buf[128] = {0};
int ret;
// 1.创建数据报套接字（socket）------------------》有手机
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
perror("socket err");
return -1;
}
printf("sockfd:%d\n", sockfd);
// 2.指定网络信息--------------------------------------》有号码
struct sockaddr_in saddr, caddr;
saddr.sin_family = AF_INET;
saddr.sin_port = htons(atoi(argv[1]));
saddr.sin_addr.s_addr = INADDR_ANY;
int len = sizeof(caddr);
// 3.绑定套接字（bind）------------------------------》绑定手机
if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
{
perror("bind err");
return -1;
}
printf("bind okk\n");
// 4.接收、发送消息（recvfrom sendto）-------》收短信
while (1)
{
// 最后两个参数存放:发送消息的人的信息
ret = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&caddr, &len);
if (ret < 0)
{
perror("recvfrom err");
return -1;
}
else
{
printf("ip:%s port:%d buf:%s\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port), buf);
memset(buf, 0, sizeof(buf));
}
}
// 5.关闭套接字（close）----------------------------》接收完毕
close(sockfd);
return 0;
}注意：
1、对于TCP是先运行服务器，客户端才能运行。
2、对于UDP来说，服务器和客户端运行顺序没有先后，因为是无连接，所以服务器和客户端谁先开始，没有关系，
3、一个服务器可以同时连接多个客户端。想知道是哪个客户端登录，可以在服务器代码里面打印IP和端口号。
4、UDP，客户端当使用send的时候，上面需要加connect，这个connect不是代表连接的作用，而是指定客户端即将要发送给谁数据。这样就不需要使用sendto而用send就可以。
5、在TCP里面，也可以使用recvfrom和sendto，使用的时候将后面的两个参数都写为NULL就OK。
【3】Linux IO模型
4种：阻塞IO、非阻塞IO、信号驱动IO（异步IO）、IO多路复用
场景假设一
假设妈妈有一个孩子，孩子在房间里睡觉，妈妈需要及时获知孩子是否醒了，如何做？
- 一直看着他，一直在一个房间呆着：不累，但是不能处理其他的事情
- 时不时的进房间看看：累，但是可以处理其他事情
- 睡觉，听孩子哭不哭：互不耽误
1. 阻塞式IO：最常见、效率低、不耗费cpu
阻塞I/O 模式是最普遍使用的I/O 模式，大部分程序使用的都是阻塞模式的I/O 。
缺省情况下（及系统默认状态），套接字建立后所处于的模式就是阻塞I/O 模式。
学习的读写函数在调用过程中会发生阻塞相关函数如下：
•读操作中的read、recv、recvfrom
读阻塞--》需要读缓冲区中有数据可读，读阻塞解除
•写操作中的write、send
写阻塞--》阻塞情况比较少，主要发生在写入的缓冲区的大小小于要写入的数据量的情况下，写操作不进行任何拷贝工作，将发生阻塞，一旦缓冲区有足够的空间，内核将唤醒进程，将数据从用户缓冲区拷贝到相应的发送数据缓冲区。
注意：sendto没有写阻塞
1）无sendto函数的原因：
sendto不是阻塞函数，本身udp通信不是面向链接的，udp无发送缓冲区，即sendto没有发送缓冲区，send是有发送缓存区的，即sendto不是阻塞函数。
2）UDP不用等待确认，没有实际的发送缓冲区，所以UDP协议中不存在缓冲区满的情况，在UDP套接字上进行写操作永远不会阻塞。
•其他操作：accept、connect
udp丢包
tcp粘包
tcp拆包
TCP粘包、拆包发生原因:
发生TCP粘包或拆包有很多原因，常见的几点：
1、要发送的数据大于TCP发送缓冲区剩余空间大小，将会发生拆包 。
2、待发送数据大于MSS（传输层的最大报文长度），将进行拆包 (到网络层拆包 - id ipflags )。
3、要发送的数据小于TCP发送缓冲区的大小，TCP将多次写入缓冲区的数据一次发送出去，将会发生粘包 。
4、接收数据端的应用层没有及时读取接收缓冲区中的数据，将发生粘包 。
粘包解决办法:
解决问题的关键在于如何给每个数据包添加边界信息，常用的方法有如下：
1、发送端给每个数据包添加包首部，首部中应该至少包含数据包的长度，这样接收端在接收到数据后，通过读取包首部的长度字段，便知道每一个数据包的实际长度了。
2、发送端将每个数据包封装为固定长度，这样接收端每次从接收缓冲区中读取固定长度的数据就自然而然的把每个数据包拆分开来。
3、可以在数据包之间设置边界，如添加特殊符号，这样，接收端通过这个边界就可以将不同的数据包拆分开。
4、延时发送
2. 非阻塞IO：轮询、耗费CPU，可以处理多路IO
•当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核："当我请求的I/O 操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。"
•当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环 来不停地测试是否一个文件描述符有数据可读（称做polling）。
•应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。
•这种模式使用中不普遍。
设置非阻塞的方式
1. 通过函数自带参数设置
2. 通过设置文件描述符的属性。把文件描述符的属性设置为非阻塞
cpp
int fcntl(int fd, int cmd, ... /* arg */ );
功能：设置文件描述符属性
参数：
fd:文件描述符
cmd：设置方式 - 功能选择
F_GETFL 获取文件描述符的状态信息 第三个参数化忽略
F_SETFL 设置文件描述符的状态信息 通过第三个参数设置
O_NONBLOCK 非阻塞
O_ASYNC 异步
O_SYNC 同步
arg:设置的值 in
返回值：
特殊选择返回特殊值 - F_GETFL 返回的状态值(int)
其他：成功0 失败-1，更新errno
使用：0为例
0-原本：阻塞、读权限 修改或添加非阻塞
int flags=fcntl(0,F_GETFL);//1.获取文件描述符原有的属性信息
flags = flags | O_NONBLOCK;//2.修改添加权限
fcntl(0,F_SETFL,flags); //3.将修改好的权限设置回去
3. 信号驱动IO/异步IO：异步通知方式，需要底层驱动的支持（了解）
异步通知：异步通知是一种非阻塞的通知机制，发送方发送通知后不需要等待接收方的响应或确认。通知发送后，发送方可以继续执行其他操作，而无需等待接收方处理通知。
-
通过信号方式，当内核检测到设备数据后，会主动给应用发送信号SIGIO。
-
应用程序收到信号后做异步处理即可。
应用程序需要把自己的进程号告诉内核，并打开异步通知机制。
cpp
//1.设置将文件描述符和进程号提交给内核驱动
//一旦fd有事件响应, 则内核驱动会给进程号发送一个SIGIO的信号
fcntl(fd,F_SETOWN,getpid());
//2.设置异步通知
int flags;
flags = fcntl(fd, F_GETFL); //获取原属性
flags |= O_ASYNC; //给flags设置异步 O_ASUNC 通知
fcntl(fd, F_SETFL, flags); //修改的属性设置进去,此时fd属于异步
//3.signal捕捉SIGIO信号 --- SIGIO:内核通知会进程有新的IO信号可用
//一旦内核给进程发送sigio信号，则执行handler
signal(SIGIO,handler);
|------|----------------------|---------------------------------------|--------------------------|
| | 阻塞IO(Blocking IO) | 非阻塞IO(Non-blocking IO) | 信号驱动IO(Signal-driven IO) |
| 同步性 | 同步 | 非同步 | 异步 |
| 描述 | 调用IO操作的线程会被阻塞，直到操作完成 | 调用IO操作时，如果不能立即完成操作，会立即返回，线程可以继续执行其他操作 | 当IO操作可以进行时，内核会发送信号通知进程 |
| 特点 | 最常见、效率低、不耗费cpu， | 轮询、耗费CPU，可以处理多路IO，效率高 | 异步通知方式，需要底层驱动的支持 |
| 适应场景 | 小规模IO操作，对性能要求不高 | 高并发网络服务器，减少线程阻塞时间 | 实时性要求高的应用，避免轮询开销 |
问题思考
● 客户端会不会知道其它客户端地址？
不知道，服务器完成，服务器存储连接的客户端信息---》链表
● 有几种消息类型？
登录
聊天
退出
● 客户端如何同时处理发送和接收？
客户端不仅需要读取服务器消息，而且需要发送消息。读取需要调用recvfrom，发送需要先调用fgets，两个都是阻塞函数。所以必须使用多任务来同时处理，可以使用多进程或者多线程来处理。
cpp
链表节点结构体：
struct node{
struct sockaddr_in addr;//data memcmp
struct node *next;
};
消息对应的结构体(同一个协议)
typedef struct msg_t
{
int type;//'L' C Q enum un{login,chat,quit};
char name[32];//用户名
char text[128];//消息正文
}MSG_t;
int memcmp(void *s1,void *s2,int size);//对比程序流程图
服务器
客户端
