2019-07-03 14:53:25 qq_35462323 阅读数 52

本文主要参考《Unix网络编程:卷1》第六章主要内容,以及结合多篇优秀博文写就。

参考博文:

https://segmentfault.com/a/1190000003063859#articleHeader17

https://zhuanlan.zhihu.com/p/63179839

https://www.cnblogs.com/fysola/p/6146063.html

 

分类

  • 阻塞式IO
  • 非阻塞式IO
  • I/O复用
  • 信号驱动式IO
  • 异步IO 

前四种为同步IO,最后一种为异步IO

IO模式

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

所以说,对一个IO操作来说,它会经历两个阶段:

  1. 等待数据:数据可能来自其他应用程序或者网络,如果没有数据,操作系统就一直等待,应用程序就跟着等待。(Waiting for the data to be ready)
  2. 拷贝数据:将就绪的数据拷贝到应用程序工作区。(Copying the data from the kernel to the process)

在Unix系统中,操作系统的IO操作是一个系统调用recvfrom(),即一个系统调用recvfrom包含两步,等待数据就绪和拷贝数据。对于一个套接字上的输入操作,第一步通常涉及等待数据从网络中到达。当所等待分组到达时,它被复制到内核中的某个缓冲区。第二步是把数据从内核缓冲区复制到应用进程缓冲区。

阻塞式IO模型

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

                                           ​

 

 

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

下面为一段典型的阻塞式调用的服务端代码:其中recv是个阻塞方法,当程序运行到recv时,它会一直等待,直到接收到数据才往下执行。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('localhost', 6999)) # 绑定要监听的端口
server.listen(5)
while True:
    conn, addr = server.accept() # 等待链接
    print(conn, addr)
    while True:
        try:
            data = conn.recv(1024)  # 接收数据
            print('recive:', data) # 打印接收到的数据
            conn.send(data.upper()) # 然后再发送数据
        except Exception as e:
            print('关闭了正在占线的链接!')
            break
    conn.close()

非阻塞式IO

linux下,可以通过设置socket使其变为non-blocking。当对一个non-blocking socket执行读操作时,流程如下图所所示。一个应用进程像这样对一个非阻塞socket循环调用recvform时,我们称之为轮询(polling),应用进程持续轮询内核,以查看某个操作是否就绪。这样做往往耗费大量cpu时间。

 

                             ​

当应用程序发起了IO请求之后,系统调用recvfrom()被执行,并且立即返回,但是返回的并不是IO处理完成的结果,而是一个特定的错误,表示IO数据没有准备好,因此不需要进行IO操作。应用程序会不停地(即轮询)执行recvfrom()系统调用,直到数据已经就绪,然后操作系统完成IO操作,recvfrom()返回成功。这个过程中,没有数据就绪时系统调用recvfrom()是立即返回的,即应用程序并没有阻塞在底层操作系统的等待数据上面,而是轮询结果。

可见阻塞IO与非阻塞IO的关键区别在于,系统调用recvfrom是否立即返回。由于轮询会消耗大量CPU时间,因此这种模式并不常用。

下面为一段非阻塞式调用的Server端代码:

​
except Exception:
            pass
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.setblocking(False)   # 把 socket 中所有需要阻塞的方法都改变成非阻塞
sk.listen(10)
​
conn_list = []     # 用来存储所有来请求 server端的 conn连接
​
while True:
    try:
        conn, addr = sk.accept() # 不阻塞,但是没有人连接会报错
        print('conn:', addr, conn)
        conn_list.append(conn)
    except Exception:
        pass
​
    tmp_list = [conn for conn in conn_list]
    for conn in tmp_list:
        try:
            data = conn.recv(1024)  # 接收数据1024字节
            if data:
                print('收到的数据是{}'.format(data.decode()))
                conn.send(data)
            else:
                print('close conn', conn)
                conn.close()
                conn_list.remove(conn)
                print('remain conn:', len(conn_list))
        except Exception:
            pass
​

Client端代码:

import socket

client = socket.socket()
client.connect(('127.0.0.1', 9999))

while True:
    msg = input(">>>")
    if msg != 'q':
        client.send(msg.encode())
        data = client.recv(1024)
        print('收到的数据{}'.format(data.decode()))
    else:
        client.close()
        print('close client socket')
        break

非阻塞IO模型优点:实现了同时服务多个客户端,能够在等待任务完成的时间里干其他活了。

非阻塞IO模型缺点:不停地轮询recv,占用较多的CPU资源。对应BlockingIOError的异常处理也是无效的CPU花费。(注:进程阻塞不占用cpu资源

 

I/O复用

IO multiplexing就是我们说的select,poll,epoll,有些地方也称这种IO方式为event driven IO。I/O复用,可以通过调用select或poll,阻塞在真正的I/O系统调用之上,而不是真正的I/O系统调用上。

select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select,poll,epoll这个function会不断的轮询所负责的所有socket,当某个socket有数据到达了,就通知用户进程。如下图所示:

 

                             ​

如上图所示, 应用进程阻塞于select调用,等待数据报套接字变为可读。当select返回套接字可读这一条件时,我们调用recvfrom把所读数据报复制到应用进程缓冲区。

比较I/O复用和阻塞式IO并不显得有什么优势,事实上,由于使用select需要两个系统调用,I/O还稍显劣势。不过使用select的优势在于我们可以等待多个描述符就绪。后面我们再具体说下I/O多路复用的优势。

 

信号驱动I/O

对于信号驱动IO, 我们首先开启套接字的信号驱动式I/O功能。并通过sigaction系统调用安装一个信号处理函数。该系统调用立即返回,我们的进程继续工作。(也即应用进程并没有被阻塞)。当数据报准备好读取时,内核就为该进程产生一个sigio信号。随后我们可以在信号处理函数中调用recvfrom读取数据报。

如下图所示:

 

 

                                           ​

信号驱动也是一种非阻塞式的IO模型,比起上面的非阻塞式IO模型,信号驱动式IO模型不需要轮询检查底层IO数据是否就绪,而是被动接收信号,然后再调用recvfrom执行IO操作。

比起多路复用IO模型来说,信号驱动IO模型针对的是一个IO的完成过程, 而多路复用IO模型针对的是多个IO同时进行时候的场景。

异步IO

异步IO(asynchronous IO)由POSIX规范定义。POSIX异步I/O函数以aio_或lio_开头。这些函数的工作机制是:告知内核启动某个操作,并让内核在整个操作(包括将数据从内核复制到我们自己的缓冲区)完成后通知我们。这种模型与前面介绍的信号驱动模型的主要区别在于:信号驱动式IO是由内核通知我们何时启动一个IO操作,而异步IO模型是由内核通知我们IO操作何时完成。如下图所示:

                                           ​

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

 

总结

同步IO与异步IO的对比

POSIX把这两个术语定义如下:

同步IO:导致请求进程阻塞,知道IO操作完成。

异步IO:不导致进程阻塞。

如下图所示,前面4种模型都属于同步IO,因为其中正在的IO操作(recvfrom)将阻塞进程。

只有异步IO模型与POSIX定义的异步IO相匹配。

 

2016-05-26 01:12:53 anxpp 阅读数 27938

转载请注明出处:http://blog.csdn.net/anxpp/article/details/51503329,谢谢!

1、介绍

    Linux 的内核将所有外部设备都看做一个文件来操作(一切皆文件),对一个文件的读写操作会调用内核提供的系统命令,返回一个file descriptor(fd,文件描述符)。而对一个socket的读写也会有响应的描述符,称为socket fd(socket文件描述符),描述符就是一个数字,指向内核中的一个结构体(文件路径,数据区等一些属性)。

    根据UNIX网络编程对I/O模型的分类,UNIX提供了5种I/O模型。

    1.1、阻塞I/O模型

    最常用的I/O模型,默认情况下,所有文件操作都是阻塞的。

    比如I/O模型下的套接字接口:在进程空间中调用recvfrom,其系统调用直到数据包到达且被复制到应用进程的缓冲区中或者发生错误时才返回,在此期间一直等待。

    进程在调用recvfrom开始到它返回的整段时间内都是被阻塞的,所以叫阻塞I/O模型。

    图示:

    01

    1.2、非阻塞I/O模型

    recvfrom从应用层到内核的时候,就直接返回一个EWOULDBLOCK错误,一般都对非阻塞I/O模型进行轮询检查这个状态,看内核是不是有数据到来。

    图示:

    02

    1.3、I/O复用模型

    Linux提供select/poll,进程通过将一个或多个fd传递给select或poll系统调用,阻塞在select操作上,这样,select/poll可以帮我们侦测多个fd是否处于就绪状态。

    select/poll是顺序扫描fd是否就绪,而且支持的fd数量有限,因此它的使用受到了一些制约。

    Linux还提供一个epoll系统调用,epoll使用基于事件驱动方式代替顺序扫描,因此性能更高。当有fd就绪时,立即回调函数rollback。

    图示:

    03

    1.4、信号驱动I/O模型

    首先开启套接口信号驱动I/O功能,并通过系统调用sigaction执行一个信号处理函数(此系统调用立即返回,进程继续工作,非阻塞)。当数据准备就绪时,就为改进程生成一个SIGIO信号,通过信号回调通知应用程序调用recvfrom来读取数据,并通知主循环函数处理树立。

    图示:

    04

    1.5、异步I/O

    告知内核启动某个操作,并让内核在整个操作完成后(包括数据的复制)通知进程。

    信号驱动I/O模型通知的是何时可以开始一个I/O操作,异步I/O模型有内核通知I/O操作何时已经完成。

    图示:

    05

2、I/O多路复用技术

    I/O编程中,需要处理多个客户端接入请求时,可以利用多线程或者I/O多路复用技术进行处理。

    正如前面的简介,I/O多路复用技术通过把多个I/O的阻塞复用到同一个select的阻塞上,从而使得系统在单线程的情况下可以同时处理多个客户端请求。

    与传统的多线程模型相比,I/O多路复用的最大优势就是系统开销小,系统不需要创建新的额外线程,也不需要维护这些线程的运行,降低了系统的维护工作量,节省了系统资源。

    主要的应用场景:

  •     服务器需要同时处理多个处于监听状态或多个连接状态的套接字。
  •     服务器需要同时处理多种网络协议的套接字。

    支持I/O多路复用的系统调用主要有select、pselect、poll、epoll。

    而当前推荐使用的是epoll,优势如下:

  •     支持一个进程打开的socket fd不受限制。
  •     I/O效率不会随着fd数目的增加而线性下将。
  •     使用mmap加速内核与用户空间的消息传递。
  •     epoll拥有更加简单的API。

3、Java中的网络IO编程

    如果只是做Java开发,以上内容只需了解即可,不必深究(随便说说而已)。

    已专门出了文章介绍:Java 网络IO编程总结(BIO、NIO、AIO均含完整实例代码)

2014-10-29 16:10:02 yeswenqian 阅读数 1200

多进程并发模型中,每一个客户端连接就需要fork 一个进程,fork 代价是昂贵的,fork 要把父进程的内存映像拷贝到子进程,并在子进程中复制所有描述字,如此等等,尽管当今的实现使用称为写时拷贝的技术,用以避免在子进程切实需要自己的拷贝之前把父进程的数据空间拷贝到了子进程。然而即便有这样的优化措施,fork 的代价仍然是昂贵的。

另外fork 返回之后父子进程之间信息的传递需要进程间通信(IPC)机制。

线程有助于解决这两个问题,线程也被成为轻权进程,线程的创建可能比进程的创建快10~100 倍,同一进程内的所有线程共享相同的全局内存,这使得线程之间易于共享信息,但这种共享也伴随着同步问题(锁机制也会带来不小的消耗)。

在服务端的线程模型实现方式一般有三种:

  1. 按需生成(来一个连接生成一个线程);
  2. 线程池(预先生成很多线程);
  3. Leader follower(LF)
这里我们先介绍第一种方式,按需生成线程。

服务端分为主线程和工作线程,主线程负责 accept 连接,监听新客户的连接请求,并与之建立连接,工作线程则负责处理服务端与客户端的数据交互。因此,即使在工作线程阻塞的情况下,也只是阻塞在线程范围内,不会影响到主线程接受和处理新客户的连接请求。回忆前面的多进程模型,父进程负责监听建立连接,子进程负责数据交互,这里手法是相同的。代码如下

服务器端:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<unistd.h>
#include<netinet/in.h>
#include <errno.h>  
#include <pthread.h>
#define PORT 6666

void client_handler(int cli_sockfd)
{
	char buf[200];
	int n;
	n = read(cli_sockfd, buf, 200);
	buf[n] = '\0';
	printf("recv data is :%s\n", buf);

	printf("input your words:");
	scanf("%s", buf);
	write(cli_sockfd, buf, strlen(buf));
	
	close(cli_sockfd);//工作线程运行结束后,可以关闭连接套接字了
}
/*线程回调函数*/
void* thread_callback(void *arg)
{
	int cli_sockfd = *(int *)arg;
	free(arg);//释放开辟内存,我们只需要知道套接字描述符
	pthread_detach(cli_sockfd);//将其变成detached状态,这样该工作线程运行结束后,相关资源都会被释放
	client_handler(cli_sockfd);    	
}

int main(int argc,char **argv)
{
	pthread_t tid;
	int ser_sockfd, *cliptr;
	int err;
	int addlen;
	struct sockaddr_in ser_addr;
	struct sockaddr_in cli_addr;
	
	ser_sockfd = socket(AF_INET,SOCK_STREAM,0);          //创建套接字
	if(ser_sockfd == -1)
	{
		printf("socket error:%s\n",strerror(errno));
		return -1;
	}
	
	bzero(&ser_addr,sizeof(ser_addr));
    
	ser_addr.sin_family = AF_INET;
	ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	ser_addr.sin_port = htons(PORT);
	
	//将网际套接口地址结构捆绑到该套接口
	err = bind(ser_sockfd,(struct sockaddr *)&ser_addr,sizeof(ser_addr));  
	if(err == -1)
	{
		printf("bind error:%s\n",strerror(errno));
		return -1;
	}
	//将套接口转换为一个监听套接口,监听等待来自客户端的连接请求
	err = listen(ser_sockfd,5);                                      
	if(err == -1)
	{
		printf("listen error\n");
		return -1;
	}
	
	printf("listen the port:\n");
	
	for(;;)
	{	
		/*主线程*/
		cliptr = (int *)malloc(sizeof(int));
		addlen = sizeof(struct sockaddr);
		*cliptr = accept(ser_sockfd,(struct sockaddr *)&cli_addr,&addlen); 
		
		pthread_create(&tid, NULL, thread_callback, (void *)cliptr);//创建工作线程 
	}
		
	return 0;
}
客户端代码:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<unistd.h>
#include<netinet/in.h>
#define PORT 6666

int main(int argc,char **argv)
{
	int sockfd;
	int err,n;
	struct sockaddr_in addr_ser;
	char sendline[200],recvline[200];
	
	sockfd = socket(AF_INET,SOCK_STREAM,0);       //创建套接字
	if(sockfd == -1)
	{
		printf("socket error\n");
		return -1;
	}
	
	bzero(&addr_ser,sizeof(addr_ser));     
	
	/*用通配地址和指定端口号装填一个网际接口地址结构*/ 
	addr_ser.sin_family = AF_INET;
	addr_ser.sin_addr.s_addr = htonl(INADDR_ANY);   
	addr_ser.sin_port = htons(PORT);                
	
	//TCP:客户(sockfd)向服务器(套接口地址结构)发起连接,主动请求
	//服务器的IP地址和端口号有参数addr_ser指定
	err = connect(sockfd,(struct sockaddr *)&addr_ser,sizeof(addr_ser));   
	if(err == -1)
	{
		printf("connect error\n");
		return -1;
	}
	
	printf("connect with server...\n");
	
	//数据传输

	printf("Input your words:");
	scanf("%s",sendline);
		
	send(sockfd,sendline,strlen(sendline),0);            
	
	printf("waiting for server...\n");
	
	n = recv(sockfd,recvline,100,0);                      
	recvline[n] = '\0'; 
	
	printf("recv data is:%s\n",recvline);	
	
	return 0;
}
其运行结果和前面的多进程并发模型一样,不同的是多线程在资源开销方面以及效率方面要优于多进程。

简洁说来,多线程并发模型(不涉及线程池)核心代码如下:

void client_handler(int cli_sockfd)
{
	read(cli_sockfd, buf, ……);
	doit(buf);
	write(cli_sockfd, buf, ……);
	close(cli_sockfd);
}
/*线程回调函数*/
void* thread_callback(void *arg)
{
	int cli_sockfd = *(int *)arg;
	free(arg);
	pthread_detach(cli_sockfd);
	client_handler(cli_sockfd);    	
}

//
bind(ser_sockfd);
listen(ser_sockfd);
for(;;)
{
	cliptr = (int *)malloc(sizeof(int));
	*cliptr = accpet(ser_sockfd, ……);
	pthread_create(……, thread_callback, (void *)cliptr);
}

多线程并发模型与多进程并发模型在实现思想上有相似之处,但在细节之处却有很大的差异,这源于多线程自身的特点。同一进程下的线程共享进程下的资源,当访问同一变量时就需要考虑同步的问题,尤其是对于已连接套接字,不能采用下面这种方式:

void client_handler(int cli_sockfd)
{
	read(cli_sockfd, buf, ……);
	doit(buf);
	write(cli_sockfd, buf, ……);
	close(cli_sockfd);
}
/*线程回调函数*/
void* thread_callback(void *arg)
{
	int cli_sockfd = *(int *)arg;//解引用取值
	pthread_detach(cli_sockfd);
	client_handler(cli_sockfd);    	
}

//
bind(ser_sockfd);
listen(ser_sockfd);
for(;;)
{
	cli_sockfd = accpet(ser_sockfd, ……);
	pthread_create(……, thread_callback, &cliptr);//套接字地址传递
}

上面创建线程最后一个参数的传递方式存在很大的弊端,事实上指针传递本身并没有错,这里传递过去的都是同一个地址,然后再回调函数中解引用获得这个地址存放的已连接套接字,但鉴于多线程的特点,我们必须考虑这样一种情况:一个客户与服务器建立连接生成一个 cli_sockfd(假设为5),在pthread_create 函数之前,也就是thread_callback 函数调用之前,恰好另一个客户与服务器建立连接并生成一个新的 cli_sockfd(假设为6),然后前面那个线程回调函数运行,通过地址(同一个地址)获得这个cli_sockfd 值,此时获得将是最终的这个cli_sockfd(也就是6),而不是先前的那个cli_sockfd(值为5),这样势必会造成连接错误。所以在指针传递连接套接字时,应该额外开辟堆内存存放,这样每次传递的不是同一个地址,使得每个线程都有各自的已连接套接字的拷贝,也就能避免出现上面的连接错误问题。


不同于多进程并发模型,在这里,主线程不能关闭已连接套接字,同一进程下的所有线程共享全部描述字,要是主线程关闭了已连接描述字,它就会终止相应的连接,工作线程也会终止出错。工作线程通信结束之后需要关闭已连接套接字,创建新线程并不会影响描述字的引用计数,都是共享同一个,线程结束不同于多进程,不会随着子进程的运行结束,自行销掉描述字。


多线程并发相比多进程并发用轻权重的线程的频繁创建来替代低效的进程创建,在一定程度上提高了程序性能,另外如果引用线程池,可以避免频繁的创建、销毁线程,更能大大提升程序性能,但是线程模型也具备先天缺陷,多线程稳定性较差,一个线程的崩溃有时会导致整个程序崩溃。进程下的所有线程共享内存资源,在临界资源的访问上,必须考虑同步的问题,处于解决这个同步问题目的而引入的锁机制在加大程序复杂性的同时,也会严重降低程序的性能,甚至在最终的性能还比不上多进程并发模型。

后续再来看看基于线程池的多线程并发模型。





2018-12-20 13:30:24 bpz31456 阅读数 79

网络通信

网络通信,就是进程间的一种通信方式,网络通信都采用客户端-服务端模型,当然与之相对的就是进程内部的通信(就是后面要讲的多线程编程里面的东西,包括同步,信号量)。

client-server模型

unix网络通信关于网络通信

I/O多路复用select(基于轮询,支持少数文件描述符)、poll(基于轮询,支撑大量文件描述符)、epoll(系统计算文件描述数量,基于回调)

select 在初始化时,指定描述符容量大小,FD_SETSIZE的值上限在不同平台上运行是不一致的windows上是64(WINSOCK.H文件中定义)和linux(ulimit -a 查找open files 项)上受限于每个进程打开的最大文件个数(默认1024)

winsock.h文件中定义

winsock.h

linux fd限制

linux fd限制
linux open files限制


这里的select 函数 后来有pselect函数支持纳秒级别超时等待

poll 在初始化时,传入的第一个参数是一个链表,表示支持的文件描述,意味着受限于内存大小

select和poll都是在每次调用监听文件描述符时,是通过轮询来遍历,随着连接数量的增加,性能会下降

epoll,基于select和poll的缺点在2.6内核中引入,epoll中epoll_create(int size)中的size不是最大值,是一个估算值,系统会动态计算出真正的值,甚至在之后的更新中,只要是个整数就行
epoll_ctl(),控制文件描述的添加、删除,文件描述符感兴趣的事件注册和更改,就是一个回调机制。在epoll_ctl中传入的事件event.events是一个枚举类型,通过|符号来添加监听事件,其中如果添加了EPOLLET,设置关联的fd为ET的工作方式(水平触发事件立即返回结果)默认工作方式是LT(边缘触发事件,等待处理完毕后返回结果)。

I/O复用,理解I/O复用,就要理解,I/O没有复用的情况,多个连接同时请求一个服务,服务就排队一个一个处理,为了解决这个问题,就提出了I/O复用,通过上面讲解的select,poll,epoll 来统一接收请求,分发任务(select、poll)或主动处理,任务结束后通知(epoll回调)来解决。

网络通信模型

单进程模式

父进程接收到请求,fork子进程来处理,处理完毕了关闭子进程,缺点是,每次都要fork新的子进程出来,开销大

preforking改进

提前fork一个子进程池,父进程接收到请求,直接使用闲置的子进程

单线程模式

进程接收到请求,直接创建一个线程,就是每个请求,对应一个线程

prethreading改进

服务器启动时,预先创建一个线程池,服务器接收到请求,使用闲置的线程处理,不用临时创建新线程

Reactor,反应堆(I/O多路复用+线程池)

一个线程(进程)或线程池(进程池)每当Reactor(s)接受到一个请求时,就分配任务给其他线程或线程池处理,其中Netty采用多Reactor(接受)多线程(处理)模式

Proactor(异步网络模型)

每个请求来时,Proactor构造器负责创建Proactor时,同时也会创建对应的Handler回调,异步处理器(内核中)把Proactor和Handler同时注册到内核当中,异步处理器完成I/O后就会通知Proactor,proactor就会回调相应的Handler
说来比较拗口,简单点讲就是内核异步处理I/O操作,通知Proactor,proacor回调handler,linux下的异步网络模型就通过Reactor+epoll模拟出来的。

总结,网络编程模型讲解到此结束,接下里会一一通过Java代码展示讲解单线程模型prethreadingreactorproactor

2015-08-13 17:17:09 a2796749 阅读数 2085

本文涉及到线程 / 时间图例,只为表明线程在各个 IO 上确实存在阻塞时延,但并不保证时延比例的正确性和 IO 执行先后的正确性;另外,本文所提及到的接口也只是笔者熟悉的 Unix/Linux 接口,并未推荐 Windows 接口,读者可以自行查阅对应的 Windows 接口。

阻塞型的网络编程接口

几乎所有的程序员第一次接触到的网络编程都是从 listen()、send()、recv() 等接口开始的。使用这些接口可以很方便的构建服务器 / 客户机的模型。

我们假设希望建立一个简单的服务器程序,实现向单个客户机提供类似于“一问一答”的内容服务。

图 1. 简单的一问一答的服务器 / 客户机模型
图 1. 简单的一问一答的服务器 / 客户机模型

我们注意到,大部分的 socket 接口都是阻塞型的。所谓阻塞型接口是指系统调用(一般是 IO 接口)不返回调用结果并让当前线程一直阻塞,只有当该系统调用获得结果或者超时出错时才返回。

实际上,除非特别指定,几乎所有的 IO 接口 ( 包括 socket 接口 ) 都是阻塞型的。这给网络编程带来了一个很大的问题,如在调用 send() 的同时,线程将被阻塞,在此期间,线程将无法执行任何运算或响应任何的网络请求。这给多客户机、多业务逻辑的网络编程带来了挑战。这时,很多程序员可能会选择多线程的方式来解决这个问题。

多线程的服务器程序

应对多客户机的网络应用,最简单的解决方式是在服务器端使用多线程(或多进程)。多线程(或多进程)的目的是让每个连接都拥有独立的线程(或进程),这样任何一个连接的阻塞都不会影响其他的连接。

具体使用多进程还是多线程,并没有一个特定的模式。传统意义上,进程的开销要远远大于线程,所以,如果需要同时为较多的客户机提供服务,则不推荐使用多进程;如果单个服务执行体需要消耗较多的 CPU 资源,譬如需要进行大规模或长时间的数据运算或文件访问,则进程较为安全。通常,使用 pthread_create () 创建新线程,fork() 创建新进程。

我们假设对上述的服务器 / 客户机模型,提出更高的要求,即让服务器同时为多个客户机提供一问一答的服务。于是有了如下的模型。

图 2. 多线程的服务器模型
图 2. 多线程的服务器模型

在上述的线程 / 时间图例中,主线程持续等待客户端的连接请求,如果有连接,则创建新线程,并在新线程中提供为前例同样的问答服务。

很多初学者可能不明白为何一个 socket 可以 accept 多次。实际上,socket 的设计者可能特意为多客户机的情况留下了伏笔,让 accept() 能够返回一个新的 socket。下面是 accept 接口的原型:

	 int accept(int s, struct sockaddr *addr, socklen_t *addrlen);

输入参数 s 是从 socket(),bind() 和 listen() 中沿用下来的 socket 句柄值。执行完 bind() 和 listen() 后,操作系统已经开始在指定的端口处监听所有的连接请求,如果有请求,则将该连接请求加入请求队列。调用 accept() 接口正是从 socket s 的请求队列抽取第一个连接信息,创建一个与 s 同类的新的 socket 返回句柄。新的 socket 句柄即是后续 read() 和 recv() 的输入参数。如果请求队列当前没有请求,则 accept() 将进入阻塞状态直到有请求进入队列。

上述多线程的服务器模型似乎完美的解决了为多个客户机提供问答服务的要求,但其实并不尽然。如果要同时响应成百上千路的连接请求,则无论多线程还是多进程都会严重占据系统资源,降低系统对外界响应效率,而线程与进程本身也更容易进入假死状态。

很多程序员可能会考虑使用“线程池”或“连接池”。“线程池”旨在减少创建和销毁线程的频率,其维持一定合理数量的线程,并让空闲的线程重新承担新的执行任务。“连接池”维持连接的缓存池,尽量重用已有的连接、减少创建和关闭连接的频率。这两种技术都可以很好的降低系统开销,都被广泛应用很多大型系统,如 websphere、tomcat 和各种数据库等。

但是,“线程池”和“连接池”技术也只是在一定程度上缓解了频繁调用 IO 接口带来的资源占用。而且,所谓“池”始终有其上限,当请求大大超过上限时,“池”构成的系统对外界的响应并不比没有池的时候效果好多少。所以使用“池”必须考虑其面临的响应规模,并根据响应规模调整“池”的大小。

对应上例中的所面临的可能同时出现的上千甚至上万次的客户端请求,“线程池”或“连接池”或许可以缓解部分压力,但是不能解决所有问题。

总之,多线程模型可以方便高效的解决小规模的服务请求,但面对大规模的服务请求,多线程模型并不是最佳方案。下一章我们将讨论用非阻塞接口来尝试解决这个问题。

非阻塞的服务器程序

以上面临的很多问题,一定程度是 IO 接口的阻塞特性导致的。多线程是一个解决方案,还一个方案就是使用非阻塞的接口。

非阻塞的接口相比于阻塞型接口的显著差异在于,在被调用之后立即返回。使用如下的函数可以将某句柄 fd 设为非阻塞状态。

	 fcntl( fd, F_SETFL, O_NONBLOCK );

下面将给出只用一个线程,但能够同时从多个连接中检测数据是否送达,并且接受数据。

图 3. 使用非阻塞的接收数据模型
图 3. 使用非阻塞的接收数据模型

在非阻塞状态下,recv() 接口在被调用后立即返回,返回值代表了不同的含义。如在本例中,

  • recv() 返回值大于 0,表示接受数据完毕,返回值即是接受到的字节数;
  • recv() 返回 0,表示连接已经正常断开;
  • recv() 返回 -1,且 errno 等于 EAGAIN,表示 recv 操作还没执行完成;
  • recv() 返回 -1,且 errno 不等于 EAGAIN,表示 recv 操作遇到系统错误 errno。

可以看到服务器线程可以通过循环调用 recv() 接口,可以在单个线程内实现对所有连接的数据接收工作。

但是上述模型绝不被推荐。因为,循环调用 recv() 将大幅度推高 CPU 占用率;此外,在这个方案中,recv() 更多的是起到检测“操作是否完成”的作用,实际操作系统提供了更为高效的检测“操作是否完成“作用的接口,例如 select()。

使用 select() 接口的基于事件驱动的服务器模型

大部分 Unix/Linux 都支持 select 函数,该函数用于探测多个文件句柄的状态变化。下面给出 select 接口的原型:

 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) 
 int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, 
        struct timeval *timeout)

这里,fd_set 类型可以简单的理解为按 bit 位标记句柄的队列,例如要在某 fd_set 中标记一个值为 16 的句柄,则该 fd_set 的第 16 个 bit 位被标记为 1。具体的置位、验证可使用 FD_SET、FD_ISSET 等宏实现。在 select() 函数中,readfds、writefds 和 exceptfds 同时作为输入参数和输出参数。如果输入的 readfds 标记了 16 号句柄,则 select() 将检测 16 号句柄是否可读。在 select() 返回后,可以通过检查 readfds 有否标记 16 号句柄,来判断该“可读”事件是否发生。另外,用户可以设置 timeout 时间。

下面将重新模拟上例中从多个客户端接收数据的模型。

图 4. 使用 select() 的接收数据模型
图 4. 使用 select() 的接收数据模型

上述模型只是描述了使用 select() 接口同时从多个客户端接收数据的过程;由于 select() 接口可以同时对多个句柄进行读状态、写状态和错误状态的探测,所以可以很容易构建为多个客户端提供独立问答服务的服务器系统。

图 5. 使用 select() 接口的基于事件驱动的服务器模型
图 5. 使用 select() 接口的基于事件驱动的服务器模型

这里需要指出的是,客户端的一个 connect() 操作,将在服务器端激发一个“可读事件”,所以 select() 也能探测来自客户端的 connect() 行为。

上述模型中,最关键的地方是如何动态维护 select() 的三个参数 readfds、writefds 和 exceptfds。作为输入参数,readfds 应该标记所有的需要探测的“可读事件”的句柄,其中永远包括那个探测 connect() 的那个“母”句柄;同时,writefds 和 exceptfds 应该标记所有需要探测的“可写事件”和“错误事件”的句柄 ( 使用 FD_SET() 标记 )。

作为输出参数,readfds、writefds 和 exceptfds 中的保存了 select() 捕捉到的所有事件的句柄值。程序员需要检查的所有的标记位 ( 使用 FD_ISSET() 检查 ),以确定到底哪些句柄发生了事件。

上述模型主要模拟的是“一问一答”的服务流程,所以,如果 select() 发现某句柄捕捉到了“可读事件”,服务器程序应及时做 recv() 操作,并根据接收到的数据准备好待发送数据,并将对应的句柄值加入 writefds,准备下一次的“可写事件”的 select() 探测。同样,如果 select() 发现某句柄捕捉到“可写事件”,则程序应及时做 send() 操作,并准备好下一次的“可读事件”探测准备。下图描述的是上述模型中的一个执行周期。

图 6. 一个执行周期
图 6. 一个执行周期

这种模型的特征在于每一个执行周期都会探测一次或一组事件,一个特定的事件会触发某个特定的响应。我们可以将这种模型归类为“事件驱动模型”。

相比其他模型,使用 select() 的事件驱动模型只用单线程(进程)执行,占用资源少,不消耗太多 CPU,同时能够为多客户端提供服务。如果试图建立一个简单的事件驱动的服务器程序,这个模型有一定的参考价值。

但这个模型依旧有着很多问题。

首先,select() 接口并不是实现“事件驱动”的最好选择。因为当需要探测的句柄值较大时,select() 接口本身需要消耗大量时间去轮询各个句柄。很多操作系统提供了更为高效的接口,如 linux 提供了 epoll,BSD 提供了 kqueue,Solaris 提供了 /dev/poll …。如果需要实现更高效的服务器程序,类似 epoll 这样的接口更被推荐。遗憾的是不同的操作系统特供的 epoll 接口有很大差异,所以使用类似于 epoll 的接口实现具有较好跨平台能力的服务器会比较困难。

其次,该模型将事件探测和事件响应夹杂在一起,一旦事件响应的执行体庞大,则对整个模型是灾难性的。如下例,庞大的执行体 1 的将直接导致响应事件 2 的执行体迟迟得不到执行,并在很大程度上降低了事件探测的及时性。

图 7. 庞大的执行体对使用 select() 的事件驱动模型的影响
图 7. 庞大的执行体对使用 select() 的事件驱动模型的影响

幸运的是,有很多高效的事件驱动库可以屏蔽上述的困难,常见的事件驱动库有 libevent 库,还有作为 libevent 替代者的 libev 库。这些库会根据操作系统的特点选择最合适的事件探测接口,并且加入了信号 (signal) 等技术以支持异步响应,这使得这些库成为构建事件驱动模型的不二选择。下章将介绍如何使用 libev 库替换 select 或 epoll 接口,实现高效稳定的服务器模型。

总结

本文围绕如何构建一个提供“一问一答”的服务器程序,先后讨论了用阻塞型的 socket 接口实现的模型,使用多线程的模型,使用 select() 接口的基于事件驱动的服务器模型,直到使用 libev 事件驱动库的服务器模型。文章对各种模型的优缺点都做了比较,从比较中得出结论,即使用“事件驱动模型”可以的实现更为高效稳定的服务器程序。文中描述的多种模型可以为读者的网络编程提供参考价值。

UNIX网络通信

阅读数 6

没有更多推荐了,返回首页