面试（十一）

一.IO多路复用

二.为什么有IO多路复用机制?

三.IO多路复用的三种实现方式

[3.1 select](#3.1 select)

[select 函数接口](#select 函数接口)

[select 使用示例](#select 使用示例)

[select 缺点](#select 缺点)

[3.2 poll](#3.2 poll)

poll函数接口

poll使用示例

poll缺点

[3.3 epoll](#3.3 epoll)

epoll函数接口

epoll使用示例

epoll缺点

[四. 进程和线程的区别](#四. 进程和线程的区别)

[五. 线程和进程的通信方式都有哪些](#五. 线程和进程的通信方式都有哪些)

[六. 多线程并发服务器](#六. 多线程并发服务器)

[七. 线程池](#七. 线程池)

[八. 深拷贝和浅拷贝](#八. 深拷贝和浅拷贝)

[九. 内存泄漏](#九. 内存泄漏)

一.IO多路复用

IO多路复用是一种同步IO模型 ，实现一个线程可以监视多个文件句柄 ；一旦某个文件句柄就绪，就能够通知应用程序进行相应的读写操作；没有文件句柄就绪时会阻塞应用程序，交出CPU，多路是指网络连接，复用指的是同一个线程

二.为什么有IO多路复用机制?

没有IO多路复用机制时，有BIO、NIO两种实现方式，但有一些问题

同步阻塞(BIO)

**·**服务端采用单线程，当accept一个请求后，在recv或send调用阻塞时，将无法accept其他请求(必须等上一个请求处recv或send完)，无法处理并发

**·**服务端采用多线程，当accept一个请求后，开启线程进行recv，可以完成并发处理，当随着请求数增加需要增加系统线程

同步非阻塞(NIO)

**·**服务端当accept一个请求后，加入fds集合，每次轮询一遍fds集合recv(非阻塞)数据，没有数据则立即返回错误

IO多路复用

· 服务器端采用单线程通过select/epoll等系统调用获取fd列表，遍历有事件的fd列表，accept/recv/send，使其能支持更多的并发连接请求

三.IO多路复用的三种实现方式

3.1 select

select 函数接口

cs 复制代码

#include <sys/select.h>
#include <sys/time.h>

#define FD_SETSIZE 1024
#define NFDBITS (8 * sizeof(unsigned long))
#define __FDSET_LONGS (FD_SETSIZE/NFDBITS)

// 数据结构(bitmap)
// 用来表示一组文件描述符的状态
typedef struct
{
    unsigned long fds_bits[__FDSET_LONGS];
}fd_set;

// API
int select{
    int max_fd, 
    fd_set *readset, 
    fd_set *writeset, 
    fd_set *exceptset, 
    struct timeval *timeout
}// 返回值就绪描述符的数目

FD_ZERO(int fd, fd_set* fds)   // 清空集合
FD_SET(int fd, fd_set* fds)    // 将给定的描述符加入集合
FD_ISSET(int fd, fd_set* fds)  // 判断指定描述符是否在集合中 
FD_CLR(int fd, fd_set* fds)    // 将给定的描述符从文件中删除

select 使用示例

cs 复制代码

int main()
{
   /*
   * 这里进行一些初始化的设置，
   * 包括socket建立，地址的设置等,
   */
  fd_set read_fs, write_fs;
  struct timeval timeout;
  int max = 0;  // 用于记录最大的fd，在轮询中时刻更新即可
 
  // 初始化比特位
  FD_ZERO(&read_fs);
  FD_ZERO(&write_fs);
 
  int nfds = 0; // 记录就绪的事件，可以减少遍历的次数


  while (1) {
    // 阻塞获取
    // 每次需要把fd从用户态拷贝到内核态
    nfds = select(max + 1, &read_fd, &write_fd, NULL, &timeout);
    // 每次需要遍历所有fd，判断有无读写事件发生
    for (int i = 0; i <= max && nfds; ++i) {
      if (i == listenfd) {
         --nfds;
         // 这里处理accept事件
         FD_SET(i, &read_fd);//将客户端socket加入到集合中
      }
      if (FD_ISSET(i, &read_fd)) {
        --nfds;
        // 这里处理read事件
      }
      if (FD_ISSET(i, &write_fd)) {
         --nfds;
        // 这里处理write事件
      }
    }

}

select 缺点

· 单个进程所打开的FD是有限制的，通过 FD_SETSIZE 设置，默认 1024

· 每次调用 select ，都需要把 fd 集合从用户态拷贝到内核态，这个开销在 fd 很多时会很大

· 对 socket 扫描时是线性扫描，采用轮询的方法，效率较低（高并发时）

3.2 poll

poll函数接口

poll与select相比，只是没有fd的限制，其它基本一样

cs 复制代码

#include <poll.h>
// 数据结构
struct pollfd {
    int fd;                         // 需要监视的文件描述符
    short events;                   // 需要内核监视的事件
    short revents;                  // 实际发生的事件
};
 
// API
int poll(struct pollfd fds[], nfds_t nfds, int timeout);

poll使用示例

cs 复制代码

// 先宏定义长度
#define MAX_POLLFD_LEN 4096  
 
int main() {
  /*
   * 在这里进行一些初始化的操作，
   * 比如初始化数据和socket等。
   */
 
  int nfds = 0;
  pollfd fds[MAX_POLLFD_LEN];
  memset(fds, 0, sizeof(fds));
  fds[0].fd = listenfd;
  fds[0].events = POLLRDNORM;
  int max  = 0;  // 队列的实际长度，是一个随时更新的，也可以自定义其他的
  int timeout = 0;
 
  int current_size = max;
  while (1) {
    // 阻塞获取
    // 每次需要把fd从用户态拷贝到内核态
    nfds = poll(fds, max+1, timeout);
    if (fds[0].revents & POLLRDNORM) {
        // 这里处理accept事件
        connfd = accept(listenfd);
        //将新的描述符添加到读描述符集合中
    }
    // 每次需要遍历所有fd，判断有无读写事件发生
    for (int i = 1; i < max; ++i) {     
      if (fds[i].revents & POLLRDNORM) { 
         sockfd = fds[i].fd
         if ((n = read(sockfd, buf, MAXLINE)) <= 0) {
            // 这里处理read事件
            if (n == 0) {
                close(sockfd);
                fds[i].fd = -1;
            }
         } else {
             // 这里处理write事件     
         }
         if (--nfds <= 0) {
            break;       
         }   
      }
    }
  }

poll缺点

· 每次调用 poll ，都需要把 fd 集合从用户态拷贝到内核态，这个开销在 fd 很多时会很大

· 对 socket 扫描时是线性扫描，采用轮询的方法，效率较低

3.3 epoll

epoll函数接口

cs 复制代码

#include <sys/epoll.h>
 
// 数据结构
// 每一个epoll对象都有一个独立的eventpoll结构体
// 用于存放通过epoll_ctl方法向epoll对象中添加进来的事件
// epoll_wait检查是否有事件发生时，只需要检查eventpoll对象中的rdlist双链表中是否有epitem元素即可
struct eventpoll {
    /*红黑树的根节点，这颗树中存储着所有添加到epoll中的需要监控的事件*/
    struct rb_root  rbr;
    /*双链表中则存放着将要通过epoll_wait返回给用户的满足条件的事件*/
    struct list_head rdlist;
};
 
// API
 
int epoll_create(int size); // 内核中间加一个 ep 对象，把所有需要监听的 socket 都放到 ep 对象中
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); // epoll_ctl 负责把 socket 增加、删除到内核红黑树
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);// epoll_wait 负责检测可读队列，没有可读 socket 则阻塞进程

epoll使用示例

cs 复制代码

int main(int argc, char* argv[])
{
   /*
   * 在这里进行一些初始化的操作，
   * 比如初始化数据和socket等。
   */
 
    // 内核中创建ep对象
    epfd=epoll_create(256);
    // 需要监听的socket放到ep中
    epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
 
    while(1) {
      // 阻塞获取
      nfds = epoll_wait(epfd,events,20,0);
      for(i=0;i<nfds;++i) {
          if(events[i].data.fd==listenfd) {
              // 这里处理accept事件
              connfd = accept(listenfd);
              // 接收新连接写到内核对象中
              epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
          } else if (events[i].events&EPOLLIN) {
              // 这里处理read事件
              read(sockfd, BUF, MAXLINE);
              //读完后准备写
              epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
          } else if(events[i].events&EPOLLOUT) {
              // 这里处理write事件
              write(sockfd, BUF, n);
              //写完后准备读
              epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
          }
      }
    }
    return 0;
}

epoll缺点

epoll只能工作在linux下

四. 进程和线程的区别

· 进程是资源分配的最小单位，线程是 CPU 调度的最小单位

· 一个进程可以包含多个线程，一个线程只能属于一个进程

· 进程间内存空间独立，线程间共享同一个内存地址

五. 线程和进程的通信方式都有哪些

线程间的通信

共享内存：同一进程内的所有线程共享相同的地址空间，所以一个线程可以直接访问另一个线程的数据
互斥锁：任何时刻只有一个线程可以访问该资源
条件变量：允许线程在某个条件满足之前阻塞等待，当条件满足时被唤醒
信号量：可以用来控制对共享资源的访问次数
原子操作：提供了一种无需额外同步机制即可安全地更新共享数据的方法

进程间的通信

管道：一种半双工的通信方式，适用于父子进程之间或者具有亲缘关系的进程之间进行通信
命名管道：可以在不相关的进程之间使用，并且可以持久化到文件系统中
消息队列：允许多个进程以队列的形式发送和接收信息
共享内存：进程间可以通过映射同一段物理内存来进行高速数据交换
信号
套接字

六. 多线程并发服务器

多线程并发服务器是一种能够同时处理多个客户端请求的服务器架构

七. 线程池

线程池是一种用于管理和复用线程的技术，它预先创建了一组线程 ，并将这些线程保存在池中。当有任务需要执行时，从线程池中取出一个空闲的线程来处理任务，任务完成后该线程不会被销毁而是返回到线程池中等待下一次使用。这种方式可以减少频繁创建和销毁线程带来的开销。

八. 深拷贝和浅拷贝

浅拷贝：浅拷贝创建了一个新的对象，然后将原始对象中所有可变引起的对象直接复制到新对象中。

深拷贝：创建了一个新的对象，还会递归地复制原始对象中的所有子对象。新对象与原始对象完全独立，互不影响

九. 内存泄漏

程序在申请内存后，未能释放不再使用的内存。

解决措施：

1.释放资源

2.使用智能指针，自动管理生命周期

3.对象池，防止频繁创建

4.避免使用全局变量