网络IO补充说明

之前也提到过了网络IO的一些模型,同步异步,这里再稍微补充下网络IO中的数据流向,方便理解。

数据流向

网络IO操作实际过程涉及到内核和调用这个IO操作的进程。以read为例,read的具体操作分为以下两个部分:

  (1)内核等待数据可读

  (2)将内核读到的数据拷贝到进程

image

阻塞非阻塞

这个比较好理解,就是一个请求能否马上得到应答结果。可以就是非阻塞,反之就是阻塞。

image

同步异步

这个概念在阻塞与非阻塞的基础之上进行理解,同时其适用的上下文环境是针对应用程序的用户空间与网络IO系统操作的内核空间之间的交互。当应用程序提交一个IO操作,需要等待或者轮询其结果的时候就是同步。如果IO操作由内核直接做完,并会在完成后通知应用程序来取结果,那么就是异步的。

image

网络编程大并发实战-IO并发线程模型

本篇章只讨论基于前文介绍的IO模型引申出来的狭义的IO并发编程模型,而非纯粹并发编程模型。基本上就是线程,进程相关的并发编程模型,需要了解其他诸如协程等其他并发编程模型,请边上走。

进程与线程

早期的单进程或者单线程的方式我们就不说,这里一般就是讨论的多进程及多线程的方式,涉及到多进程多线程就会产生资源的竞争,CPU的系统资源的竞争就会需要上下文切换,这是要耗费资源的。这里只对进程及线程的切换可能的影响做一个比较:

进程上下文切换内容:

  • 通用寄存器、状态寄存器、程序计数器等各种CPU寄存器
  • 内核栈、用户栈
  • page table, 用于虚拟地址空间和物理地址空间映射
  • process table,保存进程id,优先级,环境变量等
  • file table,保存当前进程打开文件的状态信息

线程上下文切换内容:

切换CPU中的各种寄存器。

一般来说一种方式的 优缺点都是相对的,并且一般都是由于某种特性引起的,那么多进程的优缺点也是由于进程如下特性引起的:

有独立的地址空间、可执行的代码段、打开的文件句柄、 堆、栈。

多进程的优点:简单。(正因为其地址空间的独立性,其不存在资源的竞争。所以简单)

多进程的缺点:效率低,并发能力被限制。进程切换开销:(1)用户空间与内核空间转化,(2)任务调度器的计算复杂度, (3)进程上下文切换。(进程调度是抢占式的,正因为其地址空间的独立性,当进行进程切换的时候,上下文内容就特别多,需要保存的进程缓存就比较多)

多线程的优点:上下文切换的开销要小很多。由于共享地址空间,同一个进程 的不同线程切换时,只需切换CPU中的各种寄存器,而不必进行昂贵的地址转换、缓存刷新操作。 寄存器的切换是非常高效的,通常,它的开销与一次内核态、用户态的切换相当。此外,线程间不需要 低效的IPC通信,可以访问共享的地址空间。由于线程独立顺序执行,具有较好的数据局部性(data locality)。

多线程的缺点:需要引入了原子操作、锁、条件变量、信号量等机制来解决线程互斥与同步的问题。

一个连接一个进程/线程

一般来说就是典型的 多进程/多线程 + blocking IO.   通过前面进程与线程的描述其实我们也知道,使用多进程及多线程是耗费资源的,特别是当连接数,并发数增加到一定量级之后,进程或者线程本身及其切换就会成为瓶颈。所以这种模型适合连接数或者并发数不多的情况,一般用用也是够了。

连接与进程可不可以不用一一对应,因为计算机的资源是有限。下面这种模式就解决了这个问题。

IO多路复用+多进程/线程(事件模型)

这是一个 1+n 的线程模型,一个主进程/线程,专门负责监听处理连接,当客户端连接上来之后就直接扔到select/epoll 上,轮询到有数据通信发生的时候,把处理放到多个工作线程中去,同时为了不让前面的悲剧发生,减少不必要的切换,工作线程数的设置与CPU数线性相关(一般设置为CPU内核数或者2倍(超线程))。

在这个模型中,已经可以实现大并发大连接,但是还是基于同步IO,即IO还是有阻塞。虽然连接数上来了,但是并发性能上还有优化空间,因为IO还有阻塞。那么就需要下面这个相近的并发模型了。

异步IO+多线程

这个模型跟上面的模型使用的区别就是实现真正的异步IO,其他都差不多。但这个需要操作系统内核的支持。WINDOWS系统有比较完善成熟的一套IOCP异步IO,而Linux  内核的异步IO支持稍晚,比较流行成熟的大并发还是已epoll 作为IO模型。

网络编程大并发实战-IO模型介绍

了解了前面一篇基础的网络编程基础相关内容之后,下面我们来学习下目前网络编程大并发的一大关键点:网络编程中的IO。(2015年12月更新)

一 概念说明

在进行解释之前,首先要说明几个概念:
– 用户空间和内核空间
– 进程切换
– 进程的阻塞
– 文件描述符
– 缓存 I/O

用户空间与内核空间

现在操作系统都是采用虚拟存储器,那么对32位操作系统而言,它的寻址空间(虚拟存储空间)为4G(2的32次方)。操作系统的核心是内核,独立于普通的应用程序,可以访问受保护的内存空间,也有访问底层硬件设备的所有权限。为了保证用户进程不能直接操作内核(kernel),保证内核的安全,操心系统将虚拟空间划分为两部分,一部分为内核空间,一部分为用户空间。针对linux操作系统而言,将最高的1G字节(从虚拟地址0xC0000000到0xFFFFFFFF),供内核使用,称为内核空间,而将较低的3G字节(从虚拟地址0x00000000到0xBFFFFFFF),供各个进程使用,称为用户空间。

进程切换

为了控制进程的执行,内核必须有能力挂起正在CPU上运行的进程,并恢复以前挂起的某个进程的执行。这种行为被称为进程切换。因此可以说,任何进程都是在操作系统内核的支持下运行的,是与内核紧密相关的。

从一个进程的运行转到另一个进程上运行,这个过程中经过下面这些变化:
1. 保存处理机上下文,包括程序计数器和其他寄存器。
2. 更新PCB信息。
3. 把进程的PCB移入相应的队列,如就绪、在某事件阻塞等队列。
4. 选择另一个进程执行,并更新其PCB。
5. 更新内存管理的数据结构。
6. 恢复处理机上下文。

注:总而言之就是很耗资源,具体的可以参考这篇文章:进程切换

进程的阻塞

正在执行的进程,由于期待的某些事件未发生,如请求系统资源失败、等待某种操作的完成、新数据尚未到达或无新工作做等,则由系统自动执行阻塞原语(Block),使自己由运行状态变为阻塞状态。可见,进程的阻塞是进程自身的一种主动行为,也因此只有处于运行态的进程(获得CPU),才可能将其转为阻塞状态。当进程进入阻塞状态,是不占用CPU资源的

文件描述符fd

文件描述符(File descriptor)是计算机科学中的一个术语,是一个用于表述指向文件的引用的抽象化概念。

文件描述符在形式上是一个非负整数。实际上,它是一个索引值,指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时,内核向进程返回一个文件描述符。在程序设计中,一些涉及底层的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。

缓存 I/O

缓存 I/O 又被称作标准 I/O,大多数文件系统的默认 I/O 操作都是缓存 I/O。在 Linux 的缓存 I/O 机制中,操作系统会将 I/O 的数据缓存在文件系统的页缓存( page cache )中,也就是说,数据会先被拷贝到操作系统内核的缓冲区中,然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。

缓存 I/O 的缺点:
数据在传输过程中需要在应用程序地址空间和内核进行多次数据拷贝操作,这些数据拷贝操作所带来的 CPU 以及内存开销是非常大的。

二 IO模式

刚才说了,对于一次IO访问(以read举例),数据会先被拷贝到操作系统内核的缓冲区中,然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。所以说,当一个read操作发生时,它会经历两个阶段:
1. 等待数据准备 (Waiting for the data to be ready)
2. 将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)

正式因为这两个阶段,linux系统产生了下面五种网络模式的方案。

同步:
– 阻塞 I/O(blocking IO)
– 非阻塞 I/O(nonblocking IO)
– I/O 多路复用( IO multiplexing)
– 信号驱动 I/O( signal driven IO)

异步:
– 异步 I/O(asynchronous IO)

注:由于signal driven IO在实际中并不常用,所以我这只提及剩下的四种IO Model。

阻塞 I/O(blocking IO)

在linux中,默认情况下所有的socket都是blocking,一个典型的读操作流程大概是这样:

当用户进程调用了recvfrom这个系统调用,kernel就开始了IO的第一个阶段:准备数据(对于网络IO来说,很多时候数据在一开始还没有到达。比如,还没有收到一个完整的UDP包。这个时候kernel就要等待足够的数据到来)。这个过程需要等待,也就是说数据被拷贝到操作系统内核的缓冲区中是需要一个过程的。而在用户进程这边,整个进程会被阻塞(当然,是进程自己选择的阻塞)。当kernel一直等到数据准备好了,它就会将数据从kernel中拷贝到用户内存,然后kernel返回结果,用户进程才解除block的状态,重新运行起来。

所以,blocking IO的特点就是在IO执行的两个阶段都被block了。

非阻塞 I/O(nonblocking IO)

linux下,可以通过设置socket使其变为non-blocking。当对一个non-blocking socket执行读操作时,流程是这个样子:

当用户进程发出read操作时,如果kernel中的数据还没有准备好,那么它并不会block用户进程,而是立刻返回一个error。从用户进程角度讲 ,它发起一个read操作后,并不需要等待,而是马上就得到了一个结果。用户进程判断结果是一个error时,它就知道数据还没有准备好,于是它可以再次发送read操作。一旦kernel中的数据准备好了,并且又再次收到了用户进程的system call,那么它马上就将数据拷贝到了用户内存,然后返回。

所以,nonblocking IO的特点是用户进程需要不断的主动询问kernel数据好了没有。

I/O 多路复用( IO multiplexing)

IO multiplexing就是我们说的select,poll,epoll,有些地方也称这种IO方式为event driven IO。select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select,poll,epoll这个function会不断的轮询所负责的所有socket,当某个socket有数据到达了,就通知用户进程。

当用户进程调用了select,那么整个进程会被block,而同时,kernel会“监视”所有select负责的socket,当任何一个socket中的数据准备好了,select就会返回。这个时候用户进程再调用read操作,将数据从kernel拷贝到用户进程。

所以,I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符,而这些文件描述符(套接字描述符)其中的任意一个进入读就绪状态,select()函数就可以返回。

这个图和blocking IO的图其实并没有太大的不同,事实上,还更差一些。因为这里需要使用两个system call (select 和 recvfrom),而blocking IO只调用了一个system call (recvfrom)。但是,用select的优势在于它可以同时处理多个connection。

所以,如果处理的连接数不是很高的话,使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好,可能延迟还更大。select/epoll的优势并不是对于单个连接能处理得更快,而是在于能处理更多的连接。)

在IO multiplexing Model中,实际中,对于每一个socket,一般都设置成为non-blocking,但是,如上图所示,整个用户的process其实是一直被block的。只不过process是被select这个函数block,而不是被socket IO给block。

信号驱动式U/O模型:

         可以用信号,让内核在描述符就绪时发送SIGIO信号通知我们。称为信号驱动式I/O

        我们首先开启套接字的信号驱动式I/O功能,并通过sigaction系统调用安装一个信号处理函数。该系统调用将立即返回,我们的进程继续工作,也就是说它没有被阻塞。当数据报准备好读取时,内核就为该进程产生一个SIGIO信号。我们随后既可以在信号处理函数中调用recvfrom读取数据报,并通知主循环数据已准备好待处理。也可以立即通知循环,让它读取数据报。

         无论如何处理SIGIO信号,这种模型的优势在于等待数据报到达期间进程不被阻塞。主循环可以继续执行,只要等待来自信号处理函数的通知:既可以是数据已准备好被处理,也可以是数据报已准备好被读取。

异步 I/O(asynchronous IO)

inux下的asynchronous IO其实用得很少。先看一下它的流程:

用户进程发起read操作之后,立刻就可以开始去做其它的事。而另一方面,从kernel的角度,当它受到一个asynchronous read之后,首先它会立刻返回,所以不会对用户进程产生任何block。然后,kernel会等待数据准备完成,然后将数据拷贝到用户内存,当这一切都完成之后,kernel会给用户进程发送一个signal,告诉它read操作完成了。

总结
BLOCKING和NON-BLOCKING的区别

调用blocking IO会一直block住对应的进程直到操作完成,而non-blocking IO在kernel还准备数据的情况下会立刻返回。

SYNCHRONOUS IO和ASYNCHRONOUS IO的区别

在说明synchronous IO和asynchronous IO的区别之前,需要先给出两者的定义。POSIX的定义是这样子的:
– A synchronous I/O operation causes the requesting process to be blocked until that I/O operation completes;
– An asynchronous I/O operation does not cause the requesting process to be blocked;

两者的区别就在于synchronous IO做”IO operation”的时候会将process阻塞。按照这个定义,之前所述的blocking IO,non-blocking IO,IO multiplexing都属于synchronous IO。

有人会说,non-blocking IO并没有被block啊。这里有个非常“狡猾”的地方,定义中所指的”IO operation”是指真实的IO操作,就是例子中的recvfrom这个system call。non-blocking IO在执行recvfrom这个system call的时候,如果kernel的数据没有准备好,这时候不会block进程。但是,当kernel中数据准备好的时候,recvfrom会将数据从kernel拷贝到用户内存中,这个时候进程是被block了,在这段时间内,进程是被block的。

而asynchronous IO则不一样,当进程发起IO 操作之后,就直接返回再也不理睬了,直到kernel发送一个信号,告诉进程说IO完成。在这整个过程中,进程完全没有被block。

各个IO Model的比较如图所示:

通过上面的图片,可以发现non-blocking IO和asynchronous IO的区别还是很明显的。在non-blocking IO中,虽然进程大部分时间都不会被block,但是它仍然要求进程去主动的check,并且当数据准备完成以后,也需要进程主动的再次调用recvfrom来将数据拷贝到用户内存。而asynchronous IO则完全不同。它就像是用户进程将整个IO操作交给了他人(kernel)完成,然后他人做完后发信号通知。在此期间,用户进程不需要去检查IO操作的状态,也不需要主动的去拷贝数据。

三 I/O 多路复用之select、poll、epoll详解

select,poll,epoll都是IO多路复用的机制。I/O多路复用就是通过一种机制,一个进程可以监视多个描述符,一旦某个描述符就绪(一般是读就绪或者写就绪),能够通知程序进行相应的读写操作。但select,poll,epoll本质上都是同步I/O,因为他们都需要在读写事件就绪后自己负责进行读写,也就是说这个读写过程是阻塞的,而异步I/O则无需自己负责进行读写,异步I/O的实现会负责把数据从内核拷贝到用户空间。(这里啰嗦下)

select

int select (int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

select 函数监视的文件描述符分3类,分别是writefds、readfds、和exceptfds。调用后select函数会阻塞,直到有描述副就绪(有数据 可读、可写、或者有except),或者超时(timeout指定等待时间,如果立即返回设为null即可),函数返回。当select函数返回后,可以 通过遍历fdset,来找到就绪的描述符。

select目前几乎在所有的平台上支持,其良好跨平台支持也是它的一个优点。select的一 个缺点在于单个进程能够监视的文件描述符的数量存在最大限制,在Linux上一般为1024,可以通过修改宏定义甚至重新编译内核的方式提升这一限制,但 是这样也会造成效率的降低。

poll

int poll (struct pollfd *fds, unsigned int nfds, int timeout);

不同与select使用三个位图来表示三个fdset的方式,poll使用一个 pollfd的指针实现。

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

pollfd结构包含了要监视的event和发生的event,不再使用select“参数-值”传递的方式。同时,pollfd并没有最大数量限制(但是数量过大后性能也是会下降)。 和select函数一样,poll返回后,需要轮询pollfd来获取就绪的描述符。

从上面看,select和poll都需要在返回后,通过遍历文件描述符来获取已经就绪的socket。事实上,同时连接的大量客户端在一时刻可能只有很少的处于就绪状态,因此随着监视的描述符数量的增长,其效率也会线性下降。

epoll

epoll是在2.6内核中提出的,是之前的select和poll的增强版本。相对于select和poll来说,epoll更加灵活,没有描述符限制。epoll使用一个文件描述符管理多个描述符,将用户关系的文件描述符的事件存放到内核的一个事件表中,这样在用户空间和内核空间的copy只需一次。

一 EPOLL操作过程

epoll操作过程需要三个接口,分别如下:

int epoll_create(int size);//创建一个epoll的句柄,size用来告诉内核这个监听的数目一共有多大 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

1. int epoll_create(int size);
创建一个epoll的句柄,size用来告诉内核这个监听的数目一共有多大,这个参数不同于select()中的第一个参数,给出最大监听的fd+1的值,参数size并不是限制了epoll所能监听的描述符最大个数,只是对内核初始分配内部数据结构的一个建议
当创建好epoll句柄后,它就会占用一个fd值,在linux下如果查看/proc/进程id/fd/,是能够看到这个fd的,所以在使用完epoll后,必须调用close()关闭,否则可能导致fd被耗尽。

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
函数是对指定描述符fd执行op操作。
– epfd:是epoll_create()的返回值。
– op:表示op操作,用三个宏来表示:添加EPOLL_CTL_ADD,删除EPOLL_CTL_DEL,修改EPOLL_CTL_MOD。分别添加、删除和修改对fd的监听事件。
– fd:是需要监听的fd(文件描述符)
– epoll_event:是告诉内核需要监听什么事,struct epoll_event结构如下:

struct epoll_event { __uint32_t events; /* Epoll events */ epoll_data_t data; /* User data variable */ }; //events可以是以下几个宏的集合: EPOLLIN :表示对应的文件描述符可以读(包括对端SOCKET正常关闭); EPOLLOUT:表示对应的文件描述符可以写; EPOLLPRI:表示对应的文件描述符有紧急的数据可读(这里应该表示有带外数据到来); EPOLLERR:表示对应的文件描述符发生错误; EPOLLHUP:表示对应的文件描述符被挂断; EPOLLET: 将EPOLL设为边缘触发(Edge Triggered)模式,这是相对于水平触发(Level Triggered)来说的。 EPOLLONESHOT:只监听一次事件,当监听完这次事件之后,如果还需要继续监听这个socket的话,需要再次把这个socket加入到EPOLL队列里

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待epfd上的io事件,最多返回maxevents个事件。
参数events用来从内核得到事件的集合,maxevents告之内核这个events有多大,这个maxevents的值不能大于创建epoll_create()时的size,参数timeout是超时时间(毫秒,0会立即返回,-1将不确定,也有说法说是永久阻塞)。该函数返回需要处理的事件数目,如返回0表示已超时。

二 工作模式

 epoll对文件描述符的操作有两种模式:LT(level trigger)ET(edge trigger)。LT模式是默认模式,LT模式与ET模式的区别如下:
LT模式:当epoll_wait检测到描述符事件发生并将此事件通知应用程序,应用程序可以不立即处理该事件。下次调用epoll_wait时,会再次响应应用程序并通知此事件。
ET模式:当epoll_wait检测到描述符事件发生并将此事件通知应用程序,应用程序必须立即处理该事件。如果不处理,下次调用epoll_wait时,不会再次响应应用程序并通知此事件。

1. LT模式

LT(level triggered)是缺省的工作方式,并且同时支持block和no-block socket.在这种做法中,内核告诉你一个文件描述符是否就绪了,然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作,内核还是会继续通知你的。

2. ET模式

ET(edge-triggered)是高速工作方式,只支持no-block socket。在这种模式下,当描述符从未就绪变为就绪时,内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪,并且不会再为那个文件描述符发送更多的就绪通知,直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如,你在发送,接收或者接收请求,或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误)。但是请注意,如果一直不对这个fd作IO操作(从而导致它再次变成未就绪),内核不会发送更多的通知(only once)

ET模式在很大程度上减少了epoll事件被重复触发的次数,因此效率要比LT模式高。epoll工作在ET模式的时候,必须使用非阻塞套接口,以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

3. 总结

假如有这样一个例子:
1. 我们已经把一个用来从管道中读取数据的文件句柄(RFD)添加到epoll描述符
2. 这个时候从管道的另一端被写入了2KB的数据
3. 调用epoll_wait(2),并且它会返回RFD,说明它已经准备好读取操作
4. 然后我们读取了1KB的数据
5. 调用epoll_wait(2)……

LT模式:
如果是LT模式,那么在第5步调用epoll_wait(2)之后,仍然能受到通知。

ET模式:
如果我们在第1步将RFD添加到epoll描述符的时候使用了EPOLLET标志,那么在第5步调用epoll_wait(2)之后将有可能会挂起,因为剩余的数据还存在于文件的输入缓冲区内,而且数据发出端还在等待一个针对已经发出数据的反馈信息。只有在监视的文件句柄上发生了某个事件的时候 ET 工作模式才会汇报事件。因此在第5步的时候,调用者可能会放弃等待仍在存在于文件输入缓冲区内的剩余数据。

当使用epoll的ET模型来工作时,当产生了一个EPOLLIN事件后,
读数据的时候需要考虑的是当recv()返回的大小如果等于请求的大小,那么很有可能是缓冲区还有数据未读完,也意味着该次事件还没有处理完,所以还需要再次读取:

while(rs){ buflen = recv(activeevents[i].data.fd, buf, sizeof(buf), 0); if(buflen < 0){ // 由于是非阻塞的模式,所以当errno为EAGAIN时,表示当前缓冲区已无数据可读 // 在这里就当作是该次事件已处理处. if(errno == EAGAIN){ break; } else{ return; } } else if(buflen == 0){ // 这里表示对端的socket已正常关闭. } if(buflen == sizeof(buf){ rs = 1; // 需要再次读取 } else{ rs = 0; } }

Linux中的EAGAIN含义

Linux环境下开发经常会碰到很多错误(设置errno),其中EAGAIN是其中比较常见的一个错误(比如用在非阻塞操作中)。
从字面上来看,是提示再试一次。这个错误经常出现在当应用程序进行一些非阻塞(non-blocking)操作(对文件或socket)的时候。

例如,以 O_NONBLOCK的标志打开文件/socket/FIFO,如果你连续做read操作而没有数据可读。此时程序不会阻塞起来等待数据准备就绪返回,read函数会返回一个错误EAGAIN,提示你的应用程序现在没有数据可读请稍后再试。
又例如,当一个系统调用(比如fork)因为没有足够的资源(比如虚拟内存)而执行失败,返回EAGAIN提示其再调用一次(也许下次就能成功)。

三 代码演示

下面是一段不完整的代码且格式不对,意在表述上面的过程,去掉了一些模板代码。

#define IPADDRESS "127.0.0.1" #define PORT 8787 #define MAXSIZE 1024 #define LISTENQ 5 #define FDSIZE 1000 #define EPOLLEVENTS 100 listenfd = socket_bind(IPADDRESS,PORT); struct epoll_event events[EPOLLEVENTS]; //创建一个描述符 epollfd = epoll_create(FDSIZE); //添加监听描述符事件 add_event(epollfd,listenfd,EPOLLIN); //循环等待 for ( ; ; ){ //该函数返回已经准备好的描述符事件数目 ret = epoll_wait(epollfd,events,EPOLLEVENTS,-1); //处理接收到的连接 handle_events(epollfd,events,ret,listenfd,buf); } //事件处理函数 static void handle_events(int epollfd,struct epoll_event *events,int num,int listenfd,char *buf) { int i; int fd; //进行遍历;这里只要遍历已经准备好的io事件。num并不是当初epoll_create时的FDSIZE。 for (i = 0;i < num;i++) { fd = events[i].data.fd; //根据描述符的类型和事件类型进行处理 if ((fd == listenfd) &&(events[i].events & EPOLLIN)) handle_accpet(epollfd,listenfd); else if (events[i].events & EPOLLIN) do_read(epollfd,fd,buf); else if (events[i].events & EPOLLOUT) do_write(epollfd,fd,buf); } } //添加事件 static void add_event(int epollfd,int fd,int state){ struct epoll_event ev; ev.events = state; ev.data.fd = fd; epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&ev); } //处理接收到的连接 static void handle_accpet(int epollfd,int listenfd){ int clifd; struct sockaddr_in cliaddr; socklen_t cliaddrlen; clifd = accept(listenfd,(struct sockaddr*)&cliaddr,&cliaddrlen); if (clifd == -1) perror("accpet error:"); else { printf("accept a new client: %s:%d\n",inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port); //添加一个客户描述符和事件 add_event(epollfd,clifd,EPOLLIN); } } //读处理 static void do_read(int epollfd,int fd,char *buf){ int nread; nread = read(fd,buf,MAXSIZE); if (nread == -1) { perror("read error:"); close(fd); //记住close fd delete_event(epollfd,fd,EPOLLIN); //删除监听 } else if (nread == 0) { fprintf(stderr,"client close.\n"); close(fd); //记住close fd delete_event(epollfd,fd,EPOLLIN); //删除监听 } else { printf("read message is : %s",buf); //修改描述符对应的事件,由读改为写 modify_event(epollfd,fd,EPOLLOUT); } } //写处理 static void do_write(int epollfd,int fd,char *buf) { int nwrite; nwrite = write(fd,buf,strlen(buf)); if (nwrite == -1){ perror("write error:"); close(fd); //记住close fd delete_event(epollfd,fd,EPOLLOUT); //删除监听 }else{ modify_event(epollfd,fd,EPOLLIN); } memset(buf,0,MAXSIZE); } //删除事件 static void delete_event(int epollfd,int fd,int state) { struct epoll_event ev; ev.events = state; ev.data.fd = fd; epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,&ev); } //修改事件 static void modify_event(int epollfd,int fd,int state){ struct epoll_event ev; ev.events = state; ev.data.fd = fd; epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&ev); } //注:另外一端我就省了

四 EPOLL总结

在 select/poll中,进程只有在调用一定的方法后,内核才对所有监视的文件描述符进行扫描,而epoll事先通过epoll_ctl()来注册一 个文件描述符,一旦基于某个文件描述符就绪时,内核会采用类似callback的回调机制,迅速激活这个文件描述符,当进程调用epoll_wait() 时便得到通知。(此处去掉了遍历文件描述符,而是通过监听回调的的机制。这正是epoll的魅力所在。)

epoll的优点主要是一下几个方面:
1. 监视的描述符数量不受限制,它所支持的FD上限是最大可以打开文件的数目,这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左 右,具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。select的最大缺点就是进程打开的fd是有数量限制的。这对 于连接数量比较大的服务器来说根本不能满足。虽然也可以选择多进程的解决方案( Apache就是这样实现的),不过虽然linux上面创建进程的代价比较小,但仍旧是不可忽视的,加上进程间数据同步远比不上线程间同步的高效,所以也不是一种完美的方案。

  1. IO的效率不会随着监视fd的数量的增长而下降。epoll不同于select和poll轮询的方式,而是通过每个fd定义的回调函数来实现的。只有就绪的fd才会执行回调函数。

如果没有大量的idle -connection或者dead-connection,epoll的效率并不会比select/poll高很多,但是当遇到大量的idle- connection,就会发现epoll的效率大大高于select/poll。

Java nio和多路复用

java 1.4 nio提供的select,这是一种多路复用I/O(multiplexed non-blocking I/O)模型,底层是使用select或者poll。I/O复用就是,阻塞在select或者poll系统调用的某一个之上,而不是阻塞在真正的I/O系统调用之上。JDK 5.0 update 9和JDK 6.0在linux下支持使用epoll,可以提高并发idle connection的性能(http://blogs.sun.com/alanb/entry/epoll)。
“BIO是指阻塞IO方式,即读和写必须为同步方式,NIO是指异步(用户进程未被IO阻塞)读,同步(用户进程被IO阻塞)写的方式,AIO是指异步读,异步写的方式。
在网络协议上java对于TCP/IP和UDP/IP均支持,在网络IO的操作上,目前java仅支持BIO和NIO两种方式。”

(读:读取内核状态是否准备好写:数据内核态->用户态的拷贝

网络编程大并发实战-基础概述

作为基础介绍的篇章,网络编程大并发要介绍的基础还是计算机网络的基础。网络基础的内容其实还是很多的,本篇只做一个指引性的介绍,如果要了解详情还是推荐查看书籍《网络编程卷一套接字》。本篇主要介绍网络协议及sock相关知识点.

在大学的时候我们应该都学过OSI网络体系都是分7层,但实际上的上的TCP/IP网络编程都是是5层,甚至作为程序员我们只关注4,3层相关的协议内容。具体见下图:

image

主要从数据流向连接关系两个方向介绍下传输层,网络层,网络接口层的内容及功能,当然还有一些基本概念。

 

连接关系

各层在连接中解决的问题

网络接口层(数据链路层)

网络接口层主要以网卡的MAC地址作为识别对象,借助网卡,集线器双绞线通过太网协议(广播的方式)等实现(同一网络)不同机器之间的数据通讯。协议规定传输的单位数据为一组电讯号组成的数据包叫:帧。同时一般来说每次帧大小的限制为 1518字节。这一层功能保证数据在物理设备上的无错误传输。

网络层

以太网协议可以实现同一局域网内不同机器之间的数据通讯。而网络层,主要以IP地址为识别对象,借助路由器通过IP协议等实现不通子网的数据通讯。这一层传输的是IP数据包。大小为同时IP协议的功能是无连接数据报传输、数据报路由选择和差错控制。其可靠性需要靠传输层保障。

传输层

有上面两个分层的协议及mac地址及IP地址的时候,我们已经可以在无限制的任意网络中的两台主机进行数据通讯了,而传输层可以将通讯数据准确的定位到具体的程序进程中。其依靠端口号为识别对象 (在网卡中绑定端口号及进程号),借助网卡通过TCP协议等实现进程之间的通讯。这一层中,TCP协议传输对象是数据段,UDP协议传输对象是数据报。

小结:基于分层协议,借助网卡,网关,路由器等为载体,以mac地址,ip地址,端口为识别对象,使得数据能够在任意位置的进程间进行通讯。

数据流向

  进行数据通讯过程中的各层数据流向及条件。

image

 

image

(TCP/IP数据流向)

基础概念

PCI:  协议控制信息

PDU:协议数据单元(计算机网络对等层协议交换数据的单位信息)

SDU: 服务数据单元((层与层协议之间的交互)层用户与层协议之间的传递数据单位信息)

SDU(n)  = xPDU(n+1) ;             

PDU(n) = PCI(n)+ySDU(n) = PCI(n)+zPDU(n+1);        (x,y,z>0)

segment(分节):TCP传输层的PDU。

传输层

应用层的数据字节流,并且大小不一,而到了传输层,其传输的应用层数据就要被切分格式化层message,如果是TCP协议,则为segment,这个协议传输的大小一般需要小于 MSS及MTU,原因是为了传输效率,如果把每一层的数据协议容量大小叠加起来看成漏斗,为了在传输过程中不卡壳数据重新切分(这样做会增加传输协议头相关的内容),那么最好在一开始的传输层就把数据切分处理好,方便直接通行。同时MSS这个阈值是在计算机作为参数设置的,所以也是作为调优的手段。

网络层

网络层的PDU是IP数据报,其中,IPV4协议的规定的最大容量是65535字节,IPV6协议规定的容量是65575字节,在看了后面的网络接口层厚我们可以知道这一层中容量不会成为这个传输漏斗的瓶颈。

网络接口层(链路层)

网络接口层的PDU 是 frame, 由于以太网传输电气方面的限制,每个以太网帧都有最小的大小64bytes,最大不能超过1518bytes。当两台远程PC互联的时候,它们的数据需要穿过很多的路由器和各种各样的网络媒介才能到达对端,网络中不同媒介的MTU各不相同,就好比一长段的水管,由不同粗细的水管组成(MTU不同 :))通过这段水管最大水量就要由中间最细的水管决定。同时当今的网络设备一般都支持本端网络接口层在通信前一般就会先检测出整个链路的 MTU。

小结:

从上面我们可以得出数据的流向,及其一些特性,为了在网络层不将数据进行分片,从而导致数据头传输增加,传输顺序变化等一些问题的产生,一般我们需要在传输层就把segment数据的大小限制住,这样三层结构的容量形状就如果一个菱形如下:

image

MSS的大小调整一般需要有MTU决定。

 

SOCKET

TCP连接与分组交换

 

 

image

为了建立一个可靠的TCP连接并传输数据,从图中我们看到,前3个分节用于建立连接(三路握手),最后四个分节用于终止连接。同时为了保证可靠传输,在数据应答中捎带了一个应答确认的请求(ACK),客户端还必须发送1个应答分节,为了传输一个小于服务器通告的最大分节的数据(MSS),需要至少额外 8 个分节的辅助才能完成。

但是这额外的八个分节开销给我们提供了诸如如下的特性:可靠性,动态估算客户端与服务器往返时间(RTT算法),分节排序,重传,拥塞控制(通告窗口:告知对端任何时刻它一次性能够接收多少字节数据,MSS:本连接每个分节能够接收数据大小,都在 SYN 连接分节中设置告知对端),全双工(在一条建立的连接上即可以发送数据也可以接收数据),最大分节生命周期MSL。

为了减少数据开销,目前也有把UDP协议在应用层封装上部分TCP的特性进行可靠的UDP数据通信。

上述的TCP通信状态中需要特别说明下 TIME_WAIT 状态,该停留时间最大为2倍的最大分节生命周期,2*MSL,而MSL一般为30秒左右。同时每个IP数据报都有一个TTL,限跳阈值,防止路由回路等迷路现象。TIME_WAIT 的存在有如下两个作用:

当ACKN+1丢失后,允许接收端在TIME_WAIT内重新接收到对端发来的FIN N。可靠的实现全双工连接的终止。

当某个老的重复分节数据因为回路修复等在超过MSL的时间内重新出现后,新的连接就可能收到老的分节,TIME_WAIT保证在在关闭当前连接后的TIME_WAIT时间内不能重新发起新的连接,当前连接需要等待2MSL时间才会回到初始状态,即直到所有老的分节都过期消逝。这就允许了老的重复分节的消逝。

在本进程用socket:close()关闭一个链接,会进入TIME_WAIT状态,从应用层来看该连接已经不能使用该,但从传输层来说,还是会尝试吧sendbuffer 都发送出去再发起4次握手进行连接的关闭。如果是个多进程,socket:close 只会把引用计数减一,其他进程还是可以使用该链接。

而使用该socket :shutdown,可以选择关闭数据流通方向,不可读,不可写,双边不可用。同时该效果会作用在其他进程。

 

完结

参考:

《UNIX网络编程卷1:套接字联网API》

《计算机网络》

http://www.ruanyifeng.com/blog/2012/05/internet_protocol_suite_part_i.html

 

返回

网络编程大并发实战-开篇

技术革新日新月异,特别是互联网的井喷式发展也同样敦促着网络编程技术的革新。特别是C10K,C100K,C1M这些问题的出现,成本的不断升高,都督促着网络技术的发展。本系列将从各类规模并发长连接问题实战角度出发,通过:

分析问题,解决问题,优化分析。

来对IO模型及IO框架及编程模型等一些技术在不同规模场景下的选型抛砖引玉。

本篇幅只考虑服务器编程中的网络IO部分,对于其他诸如逻辑处理部分及存储部分未有提及。

基本规划目录如下:

网络编程大并发实战-基础概述

网络编程大并发实战-IO模型介绍

网络编程大并发实战-IO模式介绍

网络编程大并发实战-IO并发编程模型

网络编程大并发实战-IO常见框架服务器介

网络编程大并发实战-C10K(问题历史分析,最优选型,问题解决,实现分析(瓶颈,优化点)

网络编程大并发实战-C100K

网络编程大并发实战-C1M

网络编程大并发实战-新技术预览

 

PS:希望本系列可以早点结束