IO模型
在UNIX/Linux下主要有4种I/O 模型:
阻塞I/O: 最常用
非阻塞I/O: 可防止进程阻塞在I/O操作上,需要轮询
I/O 多路复用: 允许同时对多个I/O进行控制
信号驱动I/O:
一种异步通信模型
阻塞I/O 模式
阻塞I/O 模式是最普遍使用的I/O 模式,大部分程序使用的都是阻塞模式的I/O 。
缺省情况下,套接字建立后所处于的模式就是阻塞I/O 模式。
前面学习的很多读写函数在调用过程中会发生阻塞。
读操作中的read、recv、recvfrom
写操作中的write、send
其他操作:accept、connect
注意:UDP函数中sendto不阻塞
读阻塞
以read函数为例:
进程调用read函数从套接字上读取数据,当套接字的接收缓冲区中还没有数据可读,函数read将发生阻塞。
它会一直阻塞下去,等待套接字的接收缓冲区中有数据可读。
经过一段时间后,缓冲区内接收到数据,于是内核便去唤醒该进程,通过read访问这些数据。
如果在进程阻塞过程中,对方发生故障,那这个进程将永远阻塞下去。
写阻塞
在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入的数据量的情况下。
这时,写操作不进行任何拷贝工作,将发生阻塞。
一量发送缓冲区内有足够的空间,内核将唤醒进程,将数据从用户缓冲区中拷贝到相应的发送数据缓冲区。
UDP不用等待确认,没有实际的发送缓冲区,所以UDP协议中不存在发送缓冲区满的情况,在UDP套接字上执行的写操作永远都不会阻塞。
非阻塞模式I/O
当我们将一个套接字设置为非阻塞模式,我们相当于告诉了系统内核:“当我请求的I/O 操作不能够马上完成,你想让我的进程进行休眠等待的时候,不要这么做,请马上返回一个错误给我。”
当一个应用程序使用了非阻塞模式的套接字,它需要使用一个循环来不停地测试是否一个文件描述符有数据可读(称做polling)。
应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。
这种模式使用中不普遍。
非阻塞模式I/O
非阻塞模式的实现
fcntl()函数
当你一开始建立一个套接字描述符的时候,系统内核将其设置为阻塞IO模式。
可以使用函数fcntl()设置一个套接字的标志为O_NONBLOCK 来实现非阻塞。
代码实现;
1.fcntl( )函数
int fcntl(int fd, int cmd, long arg);
int flag;
flag = fcntl(sockfd, F_GETFL, 0);
flag |= O_NONBLOCK;
fcntl(sockfd, F_SETFL, flag);
2.ioctl() 函数
int b_on =1;
ioctl(sock_fd, FIONBIO, &b_on);
多路复用I/O
基本常识:
1inux 中每个进程默认情况下,最多可以打开 1024 个文件,最多有 1024 个文件描述符
文件描述符的特点:
1.非负整数
2.从最小可用的数字来分配
3.每个进程启动时默认打开 0,1,2 三个文件描述符
多路复用针对不止套接字 fd,也针对普通的文件描述 fd
应用程序中同时处理多路输入输出流,若采用阻塞模式,将得不到预期的目的;
若采用非阻塞模式,对多个输入进行轮询,但又太浪费CPU时间;
若设置多个进程,分别处理一条数据通路,将新产生进程间的同步与通信问题,使程序变得更加复杂;
比较好的方法是使用I/O多路复用。其基本思想是:
先构造一张有关描述符的表,然后调用一个函数。当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回。
函数返回时告诉进程那个描述符已就绪,可以进行I/O操作。
select()/poll()实现多路复用
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int n, fd_set *read_fds, fd_set *write_fds, fd_set *except_fds, struct timeval *timeout);
#include <sys/poll.h>
int poll(struct pollfd *ufds, unsigned int nfds, int timeout);
select()参数
maxfd
所有监控的文件描述符中最大的那一个加1
read_fds
所有要读的文件文件描述符的集合
write_fds
所有要的写文件文件描述符的集合
except_fds
其他要向我们通知的文件描述符
timeout
超时设置.
Null:一直阻塞,直到有文件描述符就绪或出错
时间值为0:仅仅检测文件描述符集的状态,然后立即返回
时间值不为0:在指定时间内,如果没有事件发生,则超时返回。
函数select
在我们调用select时进程会一直阻塞直到以下的一种情况发生.
有文件可以读.
有文件可以写.
超时所设置的时间到.
为了设置文件描述符我们要使用几个宏:
FD_SET 将fd加入到fdset
FD_CLR 将fd从fdset里面清除
FD_ZERO 从fdset中清除所有的文件描述符
FD_ISSET 判断fd是否在fdset集合中
select宏的形式:
void FD_ZERO(fd_set *fdset)
void FD_SET(int fd,fd_set *fdset)
void FD_CLR(int fd,fd_set *fdset)
int FD_ISSET(int fd,fd_set *fdset)
int main (void)
{
fd_set rset;
int maxfd = -1;
struct timeval tout;
fd = socket ( ...);
bind (fd, ...);
listen (fd, ...);
while (1) {
maxfd = fd;
FD_ZERO (&rset);
FD_SET (fd, &rset);
//依次把已经建立好连接fd加入到集合中,记录下来最大的文件描述符maxfd
//...FIXME!!
#if 0
select (maxfd + 1, &rset, NULL, NULL, NULL);
#else
tout.tv_sec = 5;
tout.tv_usec = 0;
select (maxfd + 1, &rset, NULL, NULL, &tout);
#endif
if (FD_ISSET (fd, &rset)) {
newfd = accept (fd, ....);
}
//依次判断已建立连接的客户端是否有数据
//...FIXME!
}
return 0;
}
/*./client serv_ip serv_port */
#include "net.h"
void usage(char* s)
{
printf("\n%s serv_ip serv_port", s);
printf("\n\t serv_ip: server ip address");
printf("\n\t serv_port: server port(>5000)\n\n");
}
int main(int argc, char** argv)
{
int fd = -1;
int port = -1;
struct sockaddr_in sin;
if (argc != 3)
{
usage(argv[0]);
exit(1);
}
/* 1. 创建socket fd */
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("socket");
exit(1);
}
port = atoi(argv[2]);
if (port < 5000)
{
usage(argv[0]);
exit(1);
}
/*2.连接服务器 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero(&sin, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(port); //网络字节序的端口号
#if 0
sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR);
#else
if (inet_pton(AF_INET, argv[1], (void*)&sin.sin_addr) != 1)
{
perror("inet_pton");
exit(1);
}
#endif
if (connect(fd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
{
perror("connect");
exit(1);
}
printf("Client staring...OK!\n");
int ret = -1;
fd_set rset;//把关心的文件描述符加入到集合中
int maxfd = -1;//文件描述符最大值
struct timeval tout;
char buf[BUFSIZ];
while (1)
{
FD_ZERO(&rset);//对集合清零
FD_SET(0, &rset);//将标准文件描述符加入到集合中
FD_SET(fd, &rset);//将服务器的文件描述符fd加到集合中
maxfd = fd;
tout.tv_sec = 5;//结构体成员初始化
tout.tv_usec = 0;
select(maxfd + 1, &rset, NULL, NULL, &tout);//实现在集合中对这两个文件进行监控
if (FD_ISSET(0, &rset))
{ //标准键盘上有输入
//读取键盘输入,发送到网络套接字fd
bzero(buf, BUFSIZ);对buff清零
do
{
ret = read(0, buf, BUFSIZ - 1);读buff
} while (ret < 0 && EINTR == errno);
if (ret < 0)
{
perror("read");
continue;
}
if (!ret)
continue;
if (write(fd, buf, strlen(buf)) < 0)
{
perror("write() to socket");
continue;
}
if (!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR)))
{ //用户输入了quit字符
printf("Client is exiting!\n");
break;
}
}
if (FD_ISSET(fd, &rset))
{ //服务器给发送过来了数据
//读取套接字数据,处理
bzero(buf, BUFSIZ);
do
{
ret = read(fd, buf, BUFSIZ - 1);
} while (ret < 0 && EINTR == errno);
if (ret < 0)
{
perror("read from socket");
continue;
}
if (!ret)
break; /* 服务器关闭 */
//There is a BUG,FIXME!!
printf("server said: %s\n", buf);
if ((strlen(buf) > strlen(SERV_RESP_STR))
&& !strncasecmp(buf + strlen(SERV_RESP_STR), QUIT_STR, strlen(QUIT_STR)))
{ //用户输入了quit字符
printf("Sender Client is exiting!\n");
break;
}
}
}
/*4.关闭套接字 */
close(fd);
}
#include <pthread.h>
#include <signal.h>
#include "net.h"
void cli_data_handle(void* arg);
void sig_child_handle(int signo)
{
if (SIGCHLD == signo)
{
waitpid(-1, NULL, WNOHANG);
}
}
int main(void)
{
int fd = -1;
struct sockaddr_in sin;
signal(SIGCHLD, sig_child_handle);
/* 1. 创建socket fd */
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("socket");
exit(1);
}
/*优化4: 允许绑定地址快速重用 */
int b_reuse = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof(int));
/*2. 绑定 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero(&sin, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(SERV_PORT); //网络字节序的端口号
/*优化1: 让服务器程序能绑定在任意的IP上 */
#if 1
sin.sin_addr.s_addr = htonl(INADDR_ANY);
#else
if (inet_pton(AF_INET, SERV_IP_ADDR, (void*)&sin.sin_addr) != 1)
{
perror("inet_pton");
exit(1);
}
#endif
/*2.2 绑定 */
if (bind(fd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
{
perror("bind");
exit(1);
}
/*3. 调用listen()把主动套接字变成被动套接字 */
if (listen(fd, BACKLOG) < 0)
{
perror("listen");
exit(1);
}
printf("Server starting....OK!\n");
int newfd = -1;
/*4. 阻塞等待客户端连接请求 */
struct sockaddr_in cin;
socklen_t addrlen = sizeof(cin);
while (1)
{
pid_t pid = -1;
if ((newfd = accept(fd, (struct sockaddr*)&cin, &addrlen)) < 0)
{
perror("accept");
break;
}
/*创建一个子进程用于处理已建立连接的客户的交互数据*/
if ((pid = fork()) < 0)
{
perror("fork");
break;
}
if (0 == pid)
{ //子进程中
close(fd);
char ipv4_addr[16];
if (!inet_ntop(AF_INET, (void*)&cin.sin_addr, ipv4_addr, sizeof(cin)))
{
perror("inet_ntop");
exit(1);
}
printf("Clinet(%s:%d) is connected!\n", ipv4_addr, ntohs(cin.sin_port));
cli_data_handle(&newfd);
return 0;
}
else
{ //实际上此处 pid >0, 父进程中
close(newfd);
}
}
close(fd);
return 0;
}
void cli_data_handle(void* arg)
{
int newfd = *(int*)arg;
printf("Child handling process: newfd =%d\n", newfd);
//..和newfd进行数据读写
int ret = -1;
char buf[BUFSIZ];
char resp_buf[BUFSIZ + 10];
while (1)
{
bzero(buf, BUFSIZ);
do
{
ret = read(newfd, buf, BUFSIZ - 1);
} while (ret < 0 && EINTR == errno);
if (ret < 0)
{
perror("read");
exit(1);
}
if (!ret)
{ //对方已经关闭
break;
}
printf("Receive data: %s\n", buf);
if (!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR)))
{ //用户输入了quit字符
printf("Client(fd=%d) is exiting!\n", newfd);
break;
}
bzero(resp_buf, BUFSIZ + 10);
strncpy(resp_buf, SERV_RESP_STR, strlen(SERV_RESP_STR));//拷贝
strcat(resp_buf, buf); //字符串连接
do
{
ret = write(newfd, resp_buf, strlen(resp_buf));//回显
} while (ret < 0 && EINTR == errno);
}
close(newfd);
}
#ifndef __MAKEU_NET_H__
#define __MAKEU_NET_H__
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <sys/select.h>
#include <sys/time.h>
//#include <sys/types.h>
#include <unistd.h>
#define SERV_PORT 5002
#define SERV_IP_ADDR "192.168.7.246"
#define BACKLOG 5
#define QUIT_STR "quit"
#define SERV_RESP_STR "SERVER:"
#endif
TCP多路复用
关键点:
1. select( )函数里面的各个文件描述符fd_set集合的参数在select( )前后发生了变化:
前:表示关心的文件描述符集合
后:有数据的集合(如不是在超时还回情况下)
2. 那么究竟是谁动了fd_set集合的奶酪?
答曰:kernel
思考:这种模式下,多路网络连接时候能否真正多路并发处理?如果能,请说明理由,如不能,请给出改进意见
另外的函数:
int pselect(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask);
注意参数类似struct timespec 和sigset_t
select()增强
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
struct pollfd {
int fd; /* file descriptor */
short events; /* requested events */
short revents; /* returned events */
};
类似select(),稍节省空间
服务器的select未实现,后面待完善