Redis 内存碎片揭秘：成因、影响与清理策略

TCP通信

TCP发端:
    socket 
    connect 
    send
    recv 
    close 

TCP收端:
    socket 
    bind 
    listen 
    accept 
    send 
    recv 
    close 

1.connect 
  int connect(int sockfd, const struct sockaddr *addr,
                   socklen_t addrlen);
  功能:
    发送链接请求
  参数:
    sockfd:套接字文件描述符
    addr:目的地址存放空间首地址
    addrlen:IP地址的大小
  返回值:
    成功返回0
    失败返回-1 

2.send 
  ssize_t send(int sockfd, const void *buf, size_t len, int flags);
  功能:
    发送数据
  参数:
    sockfd:文件描述符
    buf:发送数据空间首地址
    len:发送数据的长度
    flags:属性默认为0 
  返回值:
    成功返回实际发送字节数
    失败返回-1 

3.recv
  ssize_t recv(int sockfd, void *buf, size_t len, int flags);
  功能:
    接收数据 
  参数:
    sockfd:套接字文件描述符 
    buf:存放数据空间首地址
    len:最大接收数据的长度
    flags:属性默认为0 
  返回值:
    成功返回实际接收字节数
    失败返回-1 
    如果对方退出,返回0 

4.listen
  int listen(int sockfd, int backlog);
  功能:
    监听客户端发送的连接请求
    该函数不会阻塞
  参数:
    sockfd:套接字文件描述符
    backlog:允许等待的尚未被处理的三次握手请求的最大个数
  返回值:
    成功返回0 
    失败返回-1 

5.accept
  int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
  功能:
    处理等待连接队列中的第一个连接请求
    该函数具有阻塞功能(如果没有人发送链接请求，会阻塞等待)
  参数:
    socket:套接字文件描述符
    address:存放IP地址的空间首地址
    addrlen:存放IP地址大小空间首地址
  返回值:
    成功返回一个新的文件描述符（为了不影响继续和其他人进行链接通信，会返回一个新的套接字专门对这个连接的IP继续进行通讯）
    失败返回-1 

TCP包头

1.序号:发送端发送数据包的编号
2.确认号:已经确认接收到的数据的编号(只有当ACK为1时,确认号才有用)

（ACK不算序列号）

TCP为什么安全可靠:
1.在通信前建立三次握手连接
    SYN
    SYN+ACK 
    ACK 

2.在通信过程中通过序列号和确认号保障数据传输的完整性
    本次发送序列号:上次收到的确认号
    本次发送确认号:上次接收到的序列号 + 实际接收的数据长度

  在传输过程中使用滑动窗口实现流量控制

3.在通信结束时使用四次挥手结束连接保障数据传输的完整性

UDP和TCP的区别:
    1.UDP和TCP都是传输层的协议
    2.UDP实现机制简单、资源开销小、不安全不可靠
    3.TCP实现机制复杂、资源开销大、安全可靠
    4.UDP是无连接的、TCP有连接的、UDP是以数据包形式传输、TCP是以流的方式传输

爬取天气（HTTP）

URL：http://api.k780.com/?app=weather.today&weaid=西安&appkey=44923&sign=c9815919d111da6c2c9ca64a304f640b&format=json
    注意:
        appkey:换成自己的APPKey
        sign:换成自己的sign标识

HTTP:
1.URL
    <协议>://<主机>:<端口>/<路径>

    协议：HTTP       80         TCP 
          HTTPS     443         TCP 
    主机:  域名  ->  域名解析服务器 -> IP地址
    端口： 可以省略, HTTP 80
                    HTTPS 443
    路径: 想要获得对应的资源

2.HTTP交互过程:
    1.建立TCP连接
    2.发送HTTP请求报文
    3.回复HTTP相应报文
    4.关闭TCP连接

网站IP:103.205.5.228:80
    
请求报文格式:
GET /?app=weather.today&weaid=%E8%A5%BF%E5%AE%89&appkey=44923&sign=c9815919d111da6c2c9ca64a304f640b&format=json HTTP/1.1\r\n
Host: api.k780.com\r\n
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/113.0\r\n
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8\r\n
Accept-Language: en-US,en;q=0.5\r\n
Connection: keep-alive\r\n\r\n

响应报文格式:
HTTP/1.1 200 OK\r\n
Server: nginx\r\n
Date: Fri, 08 Mar 2024 06:33:44 GMT\r\n
Content-Type: application/json; charset=utf-8;\r\n
Transfer-Encoding: chunked\r\n
Connection: keep-alive\r\n
Access-Control-Allow-Origin: *\r\n
\r\n
{"success":"1","result":{"weaid":"316","days":"2024-03-08","week":".........","cityno":"xian","citynm":"......","cityid":"101110101","temperature":"13.../0...","temperature_curr":"12...","humidity":"29%","aqi":"65","weather":"............","weather_curr":"...","weather_icon":"http://api.k780.com/upload/weather/d/0.gif","weather_icon1":"","wind":"......","winp":"2...","temp_high":"13","temp_low":"0","temp_curr":"12","humi_high":"0","humi_low":"0","weatid":"1","weatid1":"","windid":"4","winpid":"2","weather_iconid":"0"}}\r\n

cjson解析

见菜鸟教程

TCP并发模型

1.TCP多线程模型:
    缺点:
        1.创建线程会带来资源开销,能够实现的并发量比较有限 

2.IO模型:
    1.阻塞IO:
        没有数据到来时,可以让任务挂起,节省CPU资源开销,提高系统效率
    
    2.非阻塞IO:
        程序未接收到数据时一直执行,效率很低

    3.异步IO
        只能绑定一个文件描述符用来读取数据

    4.多路复用IO
        select
            1.select监听的集合中的文件描述符有上限限制
            2.select有内核层向用户层数据空间拷贝的过程,占用系统资源开销
            3.select必须轮询检测产生事件的文件描述符
            4.select只能工作在水平触发模式(低速模式),无法工作在边沿触发(高速模式)

        poll
            1.poll有内核层向用户层数据空间拷贝的过程,占用系统资源开销
            2.poll必须轮询检测产生事件的文件描述符
            3.poll只能工作在水平触发模式(低速模式),无法工作在边沿触发(高速模式)

        epoll 

3.函数接口:
    1.select 
      int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);
      功能:
        select监听文件描述符集合中是否有文件描述编程ready状态
      功能:
        nfds:最大文件描述符的值+1 
        readfds:读文件描述符集合
        writefds:写文件描述符集合
        exceptfds:其余文件描述符集合
        timeout:等待的时长
            NULL 一直等待
      返回值:
        成功返回文件描述符集合中的文件描述符个数
        失败返回-1 

    void FD_CLR(int fd, fd_set *set);
    功能:
        将文件描述符fd从集合中清除 

    int  FD_ISSET(int fd, fd_set *set);
    功能:
        判断文件描述符fd是否仍在集合中 

    void FD_SET(int fd, fd_set *set);
    功能:
        将文件描述符fd加入到集合中

    void FD_ZERO(fd_set *set);
    功能:
        将文件描述符集合清0 

send.c

#include "head.h"

int CreateListenSocket(char *pip, int port)
{
	int ret = 0;
	int sockfd = 0;
	struct sockaddr_in seraddr;

	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd)
	{
		perror("fail to socket");
		return -1;
	}

	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(port);
	seraddr.sin_addr.s_addr = inet_addr(pip);
	ret = bind(sockfd, (struct sockaddr *)&seraddr, sizeof(seraddr));
	if (-1 == ret)
	{
		perror("fail to bind");
		return -1;
	}

	ret = listen(sockfd, 10);
	if (-1 == ret)
	{
		perror("fail to listen");
		return -1;
	}

	return sockfd;
}

int HandleTcpClient(int confd)
{
	char tmpbuff[4096] = {0};
	ssize_t nsize = 0;

	memset(tmpbuff, 0, sizeof(tmpbuff));
	nsize = recv(confd, tmpbuff, sizeof(tmpbuff), 0);
	if (-1 == nsize)
	{
		perror("fail to recv");
		return -1;
	}
	else if (0 == nsize)
	{
		return 0;
	}

	sprintf(tmpbuff, "%s ----echo", tmpbuff);
	nsize = send(confd, tmpbuff, strlen(tmpbuff), 0);
	if (-1 == nsize)
	{
		perror("fail to send");
		return -1;
	}

	return nsize;
}

int main(void)
{
	int sockfd = 0;
	int confd = 0;
	fd_set rdfds;
	fd_set tmpfds;
	int maxfd = 0;
	int ret = 0;
	int i = 0;

	sockfd = CreateListenSocket("192.168.1.183", 50000);
	
	FD_ZERO(&rdfds);
	FD_SET(sockfd, &rdfds);
	maxfd = sockfd;

	while (1)
	{
		tmpfds = rdfds;
		ret = select(maxfd+1, &tmpfds, NULL, NULL, NULL);
		if (-1 == ret)
		{
			perror("fail to select");
			return -1;
		}
		
		if (FD_ISSET(sockfd, &tmpfds))
		{
			confd = accept(sockfd, NULL, NULL);
			if (-1 == confd)
			{
				perror("fail to accept");
				FD_CLR(sockfd, &rdfds);
				close(sockfd);
				continue;
			}

			FD_SET(confd, &rdfds);
			maxfd = maxfd > confd ? maxfd : confd;
		}
		
		for (i = sockfd+1; i <= maxfd; i++)
		{
			if (FD_ISSET(i, &tmpfds))
			{
				ret = HandleTcpClient(i);
				if (-1 == ret)
				{
					fprintf(stderr, "handle client failed!\n");
					FD_CLR(i, &rdfds);
					close(i);
					continue;
				}
				else if (0 == ret)
				{
					fprintf(stderr, "client disconnected!\n");
					FD_CLR(i, &rdfds);
					close(i);
					continue;
				}
			}
		}
	}

	close(confd);
	close(sockfd);

	return 0;
}

recv.c

#include "head.h"

int CreateTcpClient(char *pip, int port)
{
	int ret = 0;
	int sockfd = 0;
	struct sockaddr_in seraddr;

	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd)
	{
		perror("fail to socket");
		return -1;
	}
	
	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(port);
	seraddr.sin_addr.s_addr = inet_addr(pip);
	ret = connect(sockfd, (struct sockaddr *)&seraddr, sizeof(seraddr));
	if (-1 == ret)
	{
		perror("fail to connect");
		return -1;
	}
	
	return sockfd;
}

int main(void)
{
	int sockfd = 0;
	char tmpbuff[4096] = {"hello world"};
	int cnt = 0;
	ssize_t nsize = 0;

	sockfd = CreateTcpClient("192.168.1.183", 50000);
	
	while (1)
	{
		memset(tmpbuff, 0, sizeof(tmpbuff));
		sprintf(tmpbuff, "hello world --- %d", cnt);
		cnt++;
		nsize = send(sockfd, tmpbuff, strlen(tmpbuff), 0);
		if (-1 == nsize)
		{
			perror("fail to send");
			return -1;
		}

		memset(tmpbuff, 0, sizeof(tmpbuff));
		nsize = recv(sockfd, tmpbuff, sizeof(tmpbuff), 0);
		if (-1 == nsize)
		{
			perror("fail to recv");
			return -1;
		}

		printf("RECV:%s\n", tmpbuff);
	}

	close(sockfd);

	return 0;
}

    2.poll  
      int poll(struct pollfd *fds, nfds_t nfds, int timeout);
      功能:
        监听文件描述符集合是否有事件发生
      参数:
        fds:监听文件描述符集合数组空间首地址
        nfds:监听文件描述符集合元素个数
        timeout:等待的时间（-1 一直等待）
      返回值:
        成功返回产生事件的文件描述符个数
        失败返回-1 

    struct pollfd {
        int   fd;         /* file descriptor */
        short events;     /* requested events */
        short revents;    /* returned events */
    };

    fd:监听的文件描述符
    events:要监听的事件  POLLIN:是否可读  POLLOUT:是否可写
    revents:实际产生的事件 

    3.epoll 
      int epoll_create(int size);
      功能:
        创建一张内核事件表
      参数:
        size:事件的个数
      返回值:
        成功返回文件描述符
        失败返回-1 
    
      epoll_ctl 
      int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
      功能:
        维护epoll时间表
      参数:
        epfd:事件表的文件描述符
        op:
            EPOLL_CTL_ADD   添加事件
            EPOLL_CTL_MOD   修改事件
            EPOLL_CTL_DEL   删除事件
        fd:
            操作的文件描述符
        event:
            事件对应的事件 
        
        typedef union epoll_data {
            void        *ptr;
            int          fd;
            uint32_t     u32;
            uint64_t     u64;
        } epoll_data_t;

        struct epoll_event {
            uint32_t     events;      /* Epoll events */
            epoll_data_t data;        /* User data variable */
        };

      返回值:
        成功返回0 
        失败返回-1 

      epoll_wait 
      int epoll_wait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout);
      功能:
        监听事件表中的事件
      参数:
        epfd: 述符
        events:存放实际产生事件的数组空间首地址
        maxevents:最多存放事件的个数
        timeout:设定监听的时间（超过该时间则不再监听）
        -1 一直监听直到有事件发生
      返回值:
        成功返回产生事件的文件描述符个数
        失败返回-1 
        如果时间达到仍没有事件发生返回0 

还可以直接监听函数。，直接将  typedef union epoll_data {
            void        *ptr;
            int          fd;
            uint32_t     u32;
            uint64_t     u64;
        } epoll_data_t;使用void *ptr