日常学习记录8：select、poll、epoll

最新推荐文章于 2021-06-14 15:15:44 发布
最新推荐文章于 2021-06-14 15:15:44 发布
阅读量138 收藏 1
点赞数
分类专栏： 学习记录 文章标签： epoll linux c++ 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shelbyh/article/details/117818457
版权

select、poll、epoll是后端必掌握知识，这篇文章来盘一下。

1. select、poll、epoll是什么东西

select、poll、epoll是linux下I/O多路复用的三个系统调用

那什么是I/O多路复用？见日常学习记录7：I/O模型总结

2. select模型

select维护了一个记录要监听的socket的集合fd_set，当调用select()时，由内核根据IO状态在线修改fd_set的内容，由此来通知哪些被监视的socket或文件可读。

（1）每次调用select都会把fd从用户态拷贝到内核态，因此效率较低。

（2）select会在线改变fd_set，所以每次调用都要拷贝备份。

（3）一个进程所打开的fd是有限制的，由FD_SETSIZE设置，默认值是1024，因此select有最大并发数限制。

（4）select只通知有socket准备好，但不直接指出是哪些，因此每次都要遍历所有的fd来查看。

3. poll模型

poll维护了pollfd链表来记录要监听fd，它没有了select的最大并发数限制，但是其他问题没有解决（每次都要拷贝、遍历所有列表）。

4. epoll模型

epoll维护了一个链表用来存放已经就绪的事件，维护了一个红黑树来管理要监视的事件，这样一来每次有事件就绪时就不需要遍历所有的fd看哪个是就绪的了，直接用链表里的即可。

epoll把要监视的事件挂载到红黑树上，并且注册与网卡驱动关联的回调函数，当事件发生时就调用回调函数把事件加入链表。

epoll的高效 = 红黑树 + 链表 + 回调函数

支持LT水平触发与ET边沿触发，select/poll只支持LT水平触发。
LT水平触发：只要事件没有处理完毕，每一次epoll_wait都触发该事件。
ET边沿触发：无论事件是否处理完毕，仅触发一次。

（1）epoll也没有最大并发数限制，它所支持的文件描述符上限是整个系统最大可以打开的文件数目，例如在1GB内存的机器上，这个限制大概为10万左右。

（2）红黑树是维护在内核里的，因此没有了从用户态到内核态的拷贝，提高了效率。

（3）就绪了的事件都已经在链表上，因此没有了遍历所有事件，只需要取链表里的事件即可。

在这里插入图片描述

5. 代码记录

（1）select

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/fcntl.h>

// 初始化服务端的监听端口。
int initserver(int port);

int main(int argc,char *argv[])
{
  if (argc != 2)
  {
    printf("usage: ./tcpselect port\n"); return -1;
  }

  // 初始化服务端用于监听的socket。
  int listensock = initserver(atoi(argv[1]));
  printf("listensock=%d\n",listensock);

  if (listensock < 0)
  {
    printf("initserver() failed.\n"); return -1;
  }

  fd_set readfdset;  // 读事件的集合，包括监听socket和客户端连接上来的socket。
  int maxfd;  // readfdset中socket的最大值。

  // 初始化结构体，把listensock添加到集合中。
  FD_ZERO(&readfdset);

  FD_SET(listensock,&readfdset);
  maxfd = listensock;

  while (1)
  {
    // 调用select函数时，会改变socket集合的内容，所以要把socket集合保存下来，传一个临时的给select。
    fd_set tmpfdset = readfdset;

    int infds = select(maxfd+1,&tmpfdset,NULL,NULL,NULL);
    // printf("select infds=%d\n",infds);

    // 返回失败。
    if (infds < 0)
    {
      printf("select() failed.\n"); perror("select()"); break;
    }

    // 超时，在本程序中，select函数最后一个参数为空，不存在超时的情况，但以下代码还是留着。
    if (infds == 0)
    {
      printf("select() timeout.\n"); continue;
    }

    // 检查有事情发生的socket，包括监听和客户端连接的socket。
    // 这里是客户端的socket事件，每次都要遍历整个集合，因为可能有多个socket有事件。
    for (int eventfd=0; eventfd <= maxfd; eventfd++)
    {
      if (FD_ISSET(eventfd,&tmpfdset)<=0) continue;

      if (eventfd==listensock)
      { 
        // 如果发生事件的是listensock，表示有新的客户端连上来。
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
        if (clientsock < 0)
        {
          printf("accept() failed.\n"); continue;
        }

        printf ("client(socket=%d) connected ok.\n",clientsock);

        // 把新的客户端socket加入集合。
        FD_SET(clientsock,&readfdset);

        if (maxfd < clientsock) maxfd = clientsock;

        continue;
      }
      else
      {
        // 客户端有数据过来或客户端的socket连接被断开。
        char buffer[1024];
        memset(buffer,0,sizeof(buffer));

        // 读取客户端的数据。
        ssize_t isize=read(eventfd,buffer,sizeof(buffer));

        // 发生了错误或socket被对方关闭。
        if (isize <=0)
        {
          printf("client(eventfd=%d) disconnected.\n",eventfd);

          close(eventfd);  // 关闭客户端的socket。

          FD_CLR(eventfd,&readfdset);  // 从集合中移去客户端的socket。

          // 重新计算maxfd的值，注意，只有当eventfd==maxfd时才需要计算。
          if (eventfd == maxfd)
          {
            for (int ii=maxfd;ii>0;ii--)
            {
              if (FD_ISSET(ii,&readfdset))
              {
                maxfd = ii; break;
              }
            }

            printf("maxfd=%d\n",maxfd);
          }

          continue;
        }

        printf("recv(eventfd=%d,size=%d):%s\n",eventfd,isize,buffer);

        // 把收到的报文发回给客户端。
        write(eventfd,buffer,strlen(buffer));
      }
    }
  }

  return 0;
}

// 初始化服务端的监听端口。
int initserver(int port)
{
  int sock = socket(AF_INET,SOCK_STREAM,0);
  if (sock < 0)
  {
    printf("socket() failed.\n"); return -1;
  }

  // Linux如下
  int opt = 1; unsigned int len = sizeof(opt);
  setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,len);
  setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&opt,len);

  struct sockaddr_in servaddr;
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(port);

  if (bind(sock,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 )
  {
    printf("bind() failed.\n"); close(sock); return -1;
  }

  if (listen(sock,5) != 0 )
  {
    printf("listen() failed.\n"); close(sock); return -1;
  }

  return sock;
}

（2）poll

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/fcntl.h>

// ulimit -n
#define MAXNFDS  1024

// 初始化服务端的监听端口。
int initserver(int port);

int main(int argc,char *argv[])
{
  if (argc != 2)
  {
    printf("usage: ./tcppoll port\n"); return -1;
  }

  // 初始化服务端用于监听的socket。
  int listensock = initserver(atoi(argv[1]));
  printf("listensock=%d\n",listensock);

  if (listensock < 0)
  {
    printf("initserver() failed.\n"); return -1;
  }

  int maxfd;   // fds数组中需要监视的socket的大小。
  struct pollfd fds[MAXNFDS];  // fds存放需要监视的socket。

  for (int ii=0;ii<MAXNFDS;ii++) fds[ii].fd=-1; // 初始化数组，把全部的fd设置为-1。

  // 把listensock添加到数组中。
  fds[listensock].fd=listensock;
  fds[listensock].events=POLLIN;  // 有数据可读事件，包括新客户端的连接、客户端socket有数据可读和客户端socket断开三种情况。
  maxfd=listensock;

  while (1)
  {
    int infds = poll(fds,maxfd+1,5000);
    // printf("poll infds=%d\n",infds);

    // 返回失败。
    if (infds < 0)
    {
      printf("poll() failed.\n"); perror("poll():"); break;
    }

    // 超时。
    if (infds == 0)
    {
      printf("poll() timeout.\n"); continue;
    }

    // 检查有事情发生的socket，包括监听和客户端连接的socket。
    // 这里是客户端的socket事件，每次都要遍历整个集合，因为可能有多个socket有事件。
    for (int eventfd=0; eventfd <= maxfd; eventfd++)
    {
      if (fds[eventfd].fd<0) continue;

      if ((fds[eventfd].revents&POLLIN)==0) continue;

      fds[eventfd].revents=0;  // 先把revents清空。

      if (eventfd==listensock)
      {
        // 如果发生事件的是listensock，表示有新的客户端连上来。
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
        if (clientsock < 0)
        {
          printf("accept() failed.\n"); continue;
        }

        printf ("client(socket=%d) connected ok.\n",clientsock);

        if (clientsock>MAXNFDS)
        {    
          printf("clientsock(%d)>MAXNFDS(%d)\n",clientsock,MAXNFDS); close(clientsock); continue;
        }

        fds[clientsock].fd=clientsock;
        fds[clientsock].events=POLLIN; 
        fds[clientsock].revents=0; 
        if (maxfd < clientsock) maxfd = clientsock;

        printf("maxfd=%d\n",maxfd);
        continue;
      }
      else 
      {
        // 客户端有数据过来或客户端的socket连接被断开。
        char buffer[1024];
        memset(buffer,0,sizeof(buffer));

        // 读取客户端的数据。
        ssize_t isize=read(eventfd,buffer,sizeof(buffer));

        // 发生了错误或socket被对方关闭。
        if (isize <=0)
        {
          printf("client(eventfd=%d) disconnected.\n",eventfd);

          close(eventfd);  // 关闭客户端的socket。

          fds[eventfd].fd=-1;

          // 重新计算maxfd的值，注意，只有当eventfd==maxfd时才需要计算。
          if (eventfd == maxfd)
          {
            for (int ii=maxfd;ii>0;ii--)
            {
              if ( fds[ii].fd != -1)
              {
                maxfd = ii; break;
              }
            }

            printf("maxfd=%d\n",maxfd);
          }

          continue;
        }

        printf("recv(eventfd=%d,size=%d):%s\n",eventfd,isize,buffer);

        // 把收到的报文发回给客户端。
        write(eventfd,buffer,strlen(buffer));
      }
    }
  }

  return 0;
}

// 初始化服务端的监听端口。
int initserver(int port)
{
  int sock = socket(AF_INET,SOCK_STREAM,0);
  if (sock < 0)
  {
    printf("socket() failed.\n"); return -1;
  }

  // Linux如下
  int opt = 1; unsigned int len = sizeof(opt);
  setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,len);
  setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&opt,len);

  struct sockaddr_in servaddr;
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(port);

  if (bind(sock,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 )
  {
    printf("bind() failed.\n"); close(sock); return -1;
  }

  if (listen(sock,5) != 0 )
  {
    printf("listen() failed.\n"); close(sock); return -1;
  }

  return sock;
}

（3）epoll

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/types.h>

#define MAXEVENTS 100

// 把socket设置为非阻塞的方式。
int setnonblocking(int sockfd);

// 初始化服务端的监听端口。
int initserver(int port);

int main(int argc,char *argv[])
{
  if (argc != 2)
  {
    printf("usage:./tcpepoll port\n"); return -1;
  }

  // 初始化服务端用于监听的socket。
  int listensock = initserver(atoi(argv[1]));
  printf("listensock=%d\n",listensock);

  if (listensock < 0)
  {
    printf("initserver() failed.\n"); return -1;
  }

  int epollfd;

  char buffer[1024];
  memset(buffer,0,sizeof(buffer));

  // 创建一个描述符
  epollfd = epoll_create(1);

  // 添加监听描述符事件
  struct epoll_event ev;
  ev.data.fd = listensock;
  ev.events = EPOLLIN;
  epoll_ctl(epollfd,EPOLL_CTL_ADD,listensock,&ev);

  while (1)
  {
    struct epoll_event events[MAXEVENTS]; // 存放有事件发生的结构数组。

    // 等待监视的socket有事件发生。
    int infds = epoll_wait(epollfd,events,MAXEVENTS,-1);
    // printf("epoll_wait infds=%d\n",infds);

    // 返回失败。
    if (infds < 0)
    {
      printf("epoll_wait() failed.\n"); perror("epoll_wait()"); break;
    }

    // 超时。
    if (infds == 0)
    {
      printf("epoll_wait() timeout.\n"); continue;
    }

    // 遍历有事件发生的结构数组。
    for (int ii=0;ii<infds;ii++)
    {
      if ((events[ii].data.fd == listensock) &&(events[ii].events & EPOLLIN))
      {
        // 如果发生事件的是listensock，表示有新的客户端连上来。
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
        if (clientsock < 0)
        {
          printf("accept() failed.\n"); continue;
        }

        // 把新的客户端添加到epoll中。
        memset(&ev,0,sizeof(struct epoll_event));
        ev.data.fd = clientsock;
        ev.events = EPOLLIN;
        epoll_ctl(epollfd,EPOLL_CTL_ADD,clientsock,&ev);

        printf ("client(socket=%d) connected ok.\n",clientsock);

        continue;
      }
      else if (events[ii].events & EPOLLIN)
      {
        // 客户端有数据过来或客户端的socket连接被断开。
        char buffer[1024];
        memset(buffer,0,sizeof(buffer));

        // 读取客户端的数据。
        ssize_t isize=read(events[ii].data.fd,buffer,sizeof(buffer));

        // 发生了错误或socket被对方关闭。
        if (isize <=0)
        {
          printf("client(eventfd=%d) disconnected.\n",events[ii].data.fd);

          // 把已断开的客户端从epoll中删除。
          memset(&ev,0,sizeof(struct epoll_event));
          ev.events = EPOLLIN;
          ev.data.fd = events[ii].data.fd;
          epoll_ctl(epollfd,EPOLL_CTL_DEL,events[ii].data.fd,&ev);
          close(events[ii].data.fd);
          continue;
        }

        printf("recv(eventfd=%d,size=%d):%s\n",events[ii].data.fd,isize,buffer);

        // 把收到的报文发回给客户端。
        write(events[ii].data.fd,buffer,strlen(buffer));
      }
    }
  }

  close(epollfd);

  return 0;
}

// 初始化服务端的监听端口。
int initserver(int port)
{
  int sock = socket(AF_INET,SOCK_STREAM,0);
  if (sock < 0)
  {
    printf("socket() failed.\n"); return -1;
  }

  // Linux如下
  int opt = 1; unsigned int len = sizeof(opt);
  setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,len);
  setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&opt,len);

  struct sockaddr_in servaddr;
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(port);

  if (bind(sock,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 )
  {
    printf("bind() failed.\n"); close(sock); return -1;
  }

  if (listen(sock,5) != 0 )
  {
    printf("listen() failed.\n"); close(sock); return -1;
  }

  return sock;
}

// 把socket设置为非阻塞的方式。
int setnonblocking(int sockfd)
{  
  if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)  return -1;

  return 0;  
}
参考文献：

0.C语言技术网–代码来源
1.深度理解select、poll和epoll
2.Linux epoll模型详解及源码分析
3.探讨epoll原理（红黑树、rdlist的实现）

Shelbyh
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
qfil刷机工具_【国际版系统·刷机】小新 Pad Pro
weixin_39528467的博客
11-21 5229
前言与联想的朋友聊了几句，对方答应送我一部新出的小新 Pad Pro体验一下，当然体验是有代价的，总得表示表示对不？于是就有了这篇文章——的前身。写完评测的开头我就觉得无聊了，这明明只是一个主打性价比、屏幕不错的平板，并不值得大书特书，除此以外还有什么好夸的呢？思来想去我又问了问有没有操作空间，答复是：有，刷国际版系统，对于Google生态用户而言比国内的预装ZUI好用多了。于是这就有了下面内容，...
使用select需要注意的细节
那时风起
08-06 822
关于select的一些总结      在学校的时候就使用过select，但是在项目中使用的时候却犯了个错误。 select如何使用就不进行总结了，网上教程太多，以下是项目中我写的一小段代码，便于总结。 int TvsStateManager::handleProbeStreamMsg() { struct sockaddr_in addr; int fd, n,addrlen; str
Python网络编程中的select 和 poll I/O复用的简单使用
chenpeng2556的博客
09-10 94
首先列一下，sellect、poll、epoll三者的区别 select select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描...
多路复用 I/O 多路转接 select / poll / epoll
老葱的专栏
05-26 1757
多路复用的方式是真正实用的服务器程序，非多路复用的网络程序只能作为学习或着陪测的角色。本文说下个人接触过的多路复用函数：select/poll/epoll/port。kqueue的*nix系统没接触过，估计熟悉了上面四种，kqueue也只是需要熟悉一下而已。一、select模型select原型：int select(int n, fd_set *
12端口复用_select_poll
liangwenhao1108的博客
11-16 310
目录1. 端口复用1.1用途1.2多线程通信的隐患：未设置端口复用1.3设置端口复用：的位置1.4设置端口复用：的函数2. IO多路转接2.1.IO多路转接的概念为什么需要：IO多路转接IO多路转接：核心思想常用的IO多路转接函数3. select和poll的使用3.1 select3.2 select相关函数3.3 select()使用步骤02client.c02select_server.c3.4 poll3.5 poll相关函数client.c03poll_server.c 代码： https://g
Select-Poll-Epoll-small-demo:SelectPollEpoll小演示
03-29
在IT领域，尤其是在系统编程和网络编程中，`Select`、`Poll`和`Epoll`是三种常用I/O多路复用技术，用于高效管理多个并发连接。这些技术允许单个进程同时处理多个文件描述符（FD，如套接字）的读写事件，从而提高系统...
IO复用:select,poll,epoll,kqueue的详细例子
04-30
本文将深入探讨四种常见的IO复用机制：`select`、`poll`、`epoll`和`kqueue`，并结合源码分析如何在实际项目中应用它们。我们将通过分析`service.cpp`（服务端）和`client.cpp`（客户端）来理解这些机制的工作原理。...
select poll epoll 代码实例
05-14
select poll epoll 代码实例
select poll epoll
07-30
在IT行业中，网络编程是至关重要的一环，尤其是在服务器开发领域。...提供的压缩包文件中的`select`、`poll`及`epoll`示例代码可以帮助你更深入地理解和掌握这些技术，通过实践来学习它们的使用方法和性能差异。
多路并发情况下的CS模型实例 select poll epoll
05-24
为了高效地管理这些并发连接，程序员经常使用I/O复用技术，其中"select"、"poll"和"epoll"是三种常见的机制。本文将深入探讨这三种方法，并通过实例分析它们的工作原理及其优缺点。 首先，`select`函数是最早被引入...
详细解析SELECT模型
liujiayu2的专栏
07-30 4814
先看一下下面的这句代码： int iResult = recv(s, buffer,1024); 这是用来接收数据的，在默认的阻塞模式下的套接字里，recv会阻塞在那里，直到套接字连接上有数据可读，把数据读到buffer里后recv函数才会返回，不然就会一直阻塞在那里。在单线程的程序里出现这种情况会导致主线程（单线程程序里只有一个默认的主线程）被阻塞,这样整个程序被锁死在这里，如果永远没数据发
IO多路复用模型（poll、select、epoll的原理及区别）
混水的鱼
08-09 1643
IO多路复用模型 IO：input和output，一般指数据的写入、数据的读取。IO主要分成两类：硬盘IO和网络IO，本内容主要针对网络IO。复用的含义可以理解为重复使用某个事物，而在本文，这个事物是指一个线程。因此，IO多路复用，是指并发socket连接复用一个IO线程（只需要一个线程，即可为多个client同时提供socket连接请求）。如果用户程序要将数据写入或者读取数据，那么它在底层必须通过文件描述符才能达到相应的操作，因此IO多路复用与文件描述符密切相关联。 （一）文件描述符 IO多路复用的sel
poll调用深入解析
系统运维
10-23 493
poll调用和select调用实现的功能一样，都是网络IO利用的一种机制。先看一下poll的调用形式 一，poll调用 #include &lt;poll.h&gt; int poll(struct pollfd fds[], nfds_t nfds, int timeout)；struct pollfd结构如下：【在源码文件poll.h文件中】 struct pollfd { ...
封装socket
C语言实战技术
03-05 601
文章目录一、C的封装方法1、客户端2、服务端二、C++的封装方法1、客户端2、服务端3、C++封装的意义三、应用经验四、课后作业五、版权声明 book241.cpp和book242.cpp程序已经有点长了，有些啰嗦了，如果还想扩展功能，或用于多进程、多线程，程序结构将非常复杂。 不管是socket通信程序的客户端还是服务端，准备工作的代码又长又难看占地方，影响了主程序的结构，必须分离出来。 如何分...
poll()的实现与详解
ArchyLi
07-31 4033
poll不同于select使用三个位图表示fdset的方式，poll使用一个pollfd的指针来实现。 因为select的实现和poll的实现非常类似，知识描述fd集合的方式有所不同，poll使用的是pollfd而不是select中的fd_set结构，其他类似，所以poll的实现相比于select实现简单。 首先我们看下Linux下的poll()是如何描述的 一、poll()函数
多路复用IO模型中的select和epoll
一个想写小说的程序员
11-14 1474
多路复用IO模型中的select和epoll 一，前提知识——文件描述符fd 1、文件描述符简介 首先从文件描述符开始讲起。因为，对于内核而言，所有打开的文件都是通过文件描述符引用的。那么文件描述符到底是什么？ 文件描述符（file descriptor）通常是一个小的非负整数，内核用以标识一个特定进程正在访问的文件。当打开一个现有文件或创建一个新文件时，内核向进程返回一个文件描述符。当读、写一个...
日常学习记录5：通俗理解各种锁（互斥、读写、自旋、排他、共享、悲观、乐观）
Shelbyh的博客
05-28 1406
锁机制用来实现进程线程的同步互斥，保证操作数据的正确性/一致性，来一个一个盘一下： 1.互斥锁：就是经常见到的mutex，每个线程在对共享资源（比如一个作为缓冲区的全局数组）进行操作前先申请互斥锁，申请到的可以进行操作，没申请到的要阻塞阻塞阻塞！ 互斥锁的释放只能由加锁的那个线程来释放。 互斥锁只有加锁、解锁两种操作。 2.读写锁：读写锁适合用于读操作多的场景。拥有读锁的线程可以读资源，拥有写锁的线程可以写资源。 某线程对资源加读锁时，其他线程可以也可以加读锁，但是不能加写锁（意味着有人在读的时候，其他人也
日常学习记录9：虚拟内存、共享内存、内存映射
Shelbyh的博客
06-14 1244
虚拟内存也是必会必掌握概念，盘一下 1 虚拟内存 1.1 虚拟内存是什么 虚拟内存是一种内存管理方式，它通过把程序切成小块，只把目前需要的部分放入物理内存中，其他的部分暂存在磁盘上，也被称为虚拟存储器。 物理存储器和虚拟存储器都被分割为许多大小相同的块，分别称为物理页与虚拟页，二者之间的映射关系用页表记录。 1.2 虚拟内存的好处 1.扩大地址空间； 2.内存保护：每个进程运行在各自的虚拟内存地址空间，互相不能干扰对方。虚存还对特定的内存地址提供写保护，可以防止代码或数据被恶意篡改。 3.公平内存分配。采用
日常学习记录4：socket编程
Shelbyh的博客
05-19 469
记录一下socket编程的流程，分为服务端与客户端。 1.服务端（TCP）1.1 地址结构体声明1.2 创建socket1.3 地址结构体赋值1.4 绑定socket与地址结构体1.5 设置监听模式1.6 等待客户端连接1.7 与客户端通信1.8 关闭socket释放资源2.客户端（TCP）2.1 地址结构体声明2.2 创建socket2.3 地址结构体赋值2.4 连接服务器2.5 与服务端通信2.6 关闭socket释放资源3.完整代码3.1 服务端3.2 客户端 1.服务端（TCP） 1.1 地址结构
select poll epoll
最新发布
09-14
select、poll和epoll都是用于多路复用的I/O模型。它们的作用是同时监视多个文件描述符（包括socket文件描述符）的可读、可写和错误事件，并在事件就绪时通知应用程序进行相应的处理。 select和poll是传统的I/O模型...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值