一、I/O模型的概念
1、在UNIX/Linux下 主要有4中I/O模型：
- 阻塞I/O : 最常用；
- 非阻塞I/O : 可防止进程阻塞在I/O操作上，需要轮询
- I/O多路复用：允许同时对多个I/O进行控制；
- 信号驱动I/O : 一种异步通信模型；
— 前三种是同步通信模式；后一种是 异步通信模式；
2、阻塞I/O模式
- 阻塞I/O模式是最普通使用的I/O模式，大部分程序使用的都是阻塞模式的I/O;
- 缺省情况下，套接字建立后所处于的模式都是阻塞I/O模式；
- 前面学习的很多读写函数在调用过程长会发生阻塞；
- 读操作中的read 、recv 、recvfrom
- 写操作中的write 、send
- 其他操作：accept 、connect
— 读阻塞
以read函数为例：
- 进程调用read函数从套接字上读取数据，当套接字的接收缓冲区中还没有数据可读，函数read将发生阻塞；
- 它会一致阻塞下去，等待套接字的接收缓冲区中有数据可读；
- 经过一段时间后，缓冲区内接收到数据，于是内核便去唤醒该进程，通过read访问这些数据；
- 如果在进程阻塞过程中，对方发生故障，那这个进程将永远阻塞下去；
— 写阻塞
- 在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入的数据量的情况下；
- 这时，写操作不进行任何拷贝工作，将发生阻塞；
- 一旦发送缓冲区内有足够的空间，内核将唤醒进程，将数据从用户缓冲区中拷贝到相应的发送数据缓冲区；
- UDP不用等待确认，没有实际的发送缓冲区，所以UDP协议中不存在发送缓冲区满的情况，在UDP套接字上执行的写操作永远都不会阻塞；
3、非阻塞I/O模式（fcntl()函数、ioctl() 函数）
- 当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O操作不能够马上完成，你想让我的进程进程休眠等待的时候，不要这么做，请马上返回一个错误给我。”
- 当一个应用程序使用了非阻塞模式的套接字，他需要使用要给循环来不停的测试是否一个文件描述符有数据可读（称做polling）。
- 应用程序不停的Polling内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU资源的操作；
- 这种模式使用中不普遍；
- 当你一开始建立一个套接字描述符的时候，系统内核将其设置为阻塞IO模式。
可以使用函数fcntl()设置一个套接字的标志为O_NONBLOCK 来实现非阻塞。
代码实现；
int fcntl(int fd, int cmd, long arg);
int flag；
flag = fcntl(sockfd, F_GETFL, 0);
flag |= O_NONBLOCK;
fcntl(sockfd, F_SETFL, flag);
ioctl() 函数
int b_on =1;
ioctl(sock_fd, FIONBIO, &b_on);二、I/O多路复用
- I/O 多路复用监听文件不仅仅局限于 Socket文件，同样适应于 普通的文件；
- 为多个客户端 服务；
1、多路复用I/O
- 应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的；
- 若采用非阻塞模式，对多个输入仅从轮询，但又太浪费CPU时间；
- 若设置多个进程，分别处理一条数据通路，将新产生进程间的同步与通信问题，使程序变得更加复杂；
- 比较好的方法是使用I/o多路复用。其基本的思路是：
- 先构造一张有关描述符的表，然后调用一个函数。当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回；
- 函数返回时告诉进程哪个描述符已就绪，可以进行I/O操作；
2、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(),稍节省空间
struct pollfd {
int fd; /* file descriptor */
short events; /* requested events */
short revents; /* returned events */
};
- select()参数：
maxfd：所有监控的文件描述符中最大的那一个加1；
read_fds：所有要读的文件描述符的集合；
write_fds：所有要写的文件描述符的集合；
except_fds：其它要向我们通知的文件描述符
timeout：超时设置；
NULL：一直阻塞，直到有文件描述符就绪或出错；
时间值为0：仅仅检测文件描述符集的状态，然后立即返回；
时间值不为0：在指定时间内，如果没有事件发生，则超时返回；
struct timeval {
long tv_sec; /* seconds 秒*/
long tv_usec; /* microseconds 微妙*/
};3、编程中使用 I/O多路复用的基本步骤
- linux中每个进程默认情况下，最多可以打开1024个文件，最多有1024个文件描述符
- 文件描述符的特点：
- 非负整数；
- 从最小可用的数字来分配；
- 每个进程启动时默认打开0，1，2三个文件描述符；
- 多路复用针对布置套接字fd,也针对普通的文件描述符；
- 编程中 使用 I/O多路复用 的步骤：
- 把关心文件描述符加入到集合中（fd_set）;
- 调用select()/poll()函数监控集合 fd_set 中 那些文件描述符。（阻塞等待集合中一个或多个文件描述符有数据）;
- 当有数据时，退出select()阻塞;
- 依次判断哪个文件描述符有数据；
- 依次处理有数据的文件描述符中的数据；
注：fd_set集合中，每一位代表以恶文件描述符；其中maxfa+1 一般时4个字节的整数；
4、I/O 多路复用编程 基本接口
关键点：
- select()函数里面的各个文件描述符fd_set集合的参数在select()前后发生了变化：
- 前：表示关心的文件描述符集合；
- 后：有数据的集合（如不是在超时还回情况下）；
- 那么究竟是对 fd_set集合动力手脚
- 答案：kernel
思考：
这种模式下，多路网络接连时候能否真正多路并发处理？
- 在我们调用select时进程会一直阻塞直到以下的一种情况发生.
· 有文件可以读.
·有文件可以写.
·超时所设置的时间到.
- 为了设置文件描述符我们要使用几个宏：
宏 形式 含义
FD_SET void FD_SET(int fd,fd_set *fdset) 将fd加入到fdset
FD_CLR void FD_CLR(int fd,fd_set *fdset) 将fd从fdset里面清除
FD_ZERO void FD_ZERO(fd_set *fdset) 从fdset中清除所有的文件描述符
FD_ISSET int FD_ISSET(int fd,fd_set *fdset) 判断fd是否在fdset集合中
三、I/O多路 复用 示例
- 网络编程中，read读取的数据 返回值为0，可能说明服务器已关闭；
1、客户端方的 I/O多路复用
#include "net.h"
void usage(const char* s){
printf("\n %s serv_ip ser_port \n",s);
printf("\n\t serv_ip: server ip address");
printf("\r\n serv_port: server port(>5000)\n\n");
}
int main(int argc, const char *argv[])
{
int fd = -1;
int port = 0;
struct sockaddr_in sin;
/* 1、创建socket fd */
if((fd = socket(AF_INET , SOCK_STREAM,0)) < 0 ){
perror("socket");
exit(1);
}
if(argc != 3 ){
usage(argv[0]);
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(inet_pton( AF_INET, argv[1],(void*)&sin.sin_addr.s_addr) != 1) {
perror("inet_pton");
goto _error1;
}
/* 2、2 连接服务器 */
if( connect(fd ,(struct sockaddr *)&sin,sizeof(sin)) < 0){
perror("connect");
goto _error1;
}
printf("Client staring .... OK! \n");
/* 3、读写数据*/
fd_set rset;
int maxfd;
struct timeval tout;
int ret = -1;
char buf[BUFSIZ];
while(1)
{
FD_ZERO(&rset);
FD_SET(0,&rset);
FD_SET(fd,&rset);
maxfd = fd;
tout.tv_sec = 5;
tout.tv_usec = 0;
select(maxfd+1,&rset,NULL,NULL,&tout);
if(FD_ISSET(0,&rset))//标准输入里面是不是输入
{
/*读取键盘输入，发送到网络套接字文件*/
bzero(buf,BUFSIZ);
do
{
ret = read(0,buf,BUFSIZ-1);
}while(ret <0&&EINTR == errno);
if(ret <0)
{
perror("read");
continue;
}
if(ret == 0)
{
continue;
}
if(write(fd,buf,strlen(buf)) < 0)
{
perror("write() to socket");
continue;
}
if(strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)) == 0)
{
printf("Client is existing !\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 == 0)
{
continue;
}
printf("server said:%s ",buf);
if((strlen(buf) > strlen(SERV_RESP_STR)) && strncasecmp(buf+strlen(SERV_RESP_STR),QUIT_STR,strlen(QUIT_STR)) == 0)
{
printf("sender Client is existing !\n");
break;
}
}
}
_error1:
/* 4、关闭套接字*/
close(fd);
return 0;
}2、select服务器的 改写
#include "net.h"
#include "linklist.h"
#include <sys/ioctl.h>
/* 线程传参 */
typedef struct{
int addr;//客户端IP地址
int port;//客户端端口号
int fd;//为请求链接的客户端分配的新的socket fd
}ARG;
/* IO多路复用select()处理函数 */
void do_select(int fd);
int main(int argc, const char *argv[])
{
int fd;
struct sockaddr_in sin;//如果是IPV6的编程，要使用struct sockddr_in6结构体（详细情况请参考man 7 ipv6）,通常更通用的方法可以通过struct sockaddr_storage来编程
/* 1 创建socket fd */
if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
{
perror("socket");
exit(-1);
}
/* 优化 1 允许绑定地址快速重用 */
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);
#if 1
/* 优化 2 让服务器可以绑定在任意的IP上*/
sin.sin_addr.s_addr = htonl(INADDR_ANY);
#else
if(inet_pton(AF_INET,SERV_IP_ADDR,(void *)&sin.sin_addr.s_addr) < 0)
{
perror("inet_pton");
goto _error1;
}
#endif
/* 2.2 绑定*/
if(bind(fd,(struct sockaddr *)&sin,sizeof(sin)))
{
perror("bind");
goto _error1;
}
/* 3 使用listen()把主动套接字变成被动套接字 */
if(listen(fd,BACKLOG) < 0)
{
perror("listen");
goto _error1;
}
do_select(fd);
_error1:
close(fd);
return 0;
}
void do_select(int fd)
{
linklist fdlist,sin_list;//创建一个列表，用于文件描述符及客户端信息存储
fdlist = create_linklist();
datatype sin_data;//每个对象包括客户端的socket fd,ipv4地址，端口号
sin_data.fd = fd;
int maxfd = fd;
//struct timeval tout = {5,0};
insert_end_linklist(fdlist,sin_data);//将lsten()处理后的fd加入列表
//show_linklist(fdlist);
fd_set rset;
int newfd = -1;
int ret = -1;
char buf[BUFSIZ];//BUFSIZ是系统提供的
char resp_buf[BUFSIZ+10];
struct sockaddr_in cin;
socklen_t cin_addr_len = sizeof(cin);
/* 用select()函数实现I/O多路复用*/
while(1)
{
int i;
FD_ZERO(&rset);
if(get_length_linklist(fdlist) >= 1)//将列表中的fd加入读集合进行处理
{
//puts("11111111111111111111111111111");
for(i=0;i<get_length_linklist(fdlist);i++)
{
sin_list = get_list_pos_linklist(fdlist,i);
sin_data = sin_list->data;
FD_SET(sin_data.fd,&rset);
maxfd = sin_data.fd > maxfd ? sin_data.fd : maxfd;
//printf("第 %d 个（fd:%d）（ip:%s）（port:%d）\n",i,sin_data.fd,sin_data.ipv4_addr,sin_data.port);
}
//show_linklist(fdlist);
}
else
{
continue ;
}
//switch(select(maxfd+1,&rset,NULL,NULL,&tout))
switch(select(maxfd+1,&rset,NULL,NULL,NULL))
{
case 0:
{
printf("time out!\n");
goto _error1;
}
case -1:
{
perror("select");
goto _error1;
}
default:
{
if(FD_ISSET(fd,&rset))//有客户端发送了连接请求
{
if((newfd = accept(fd,(struct sockaddr *)&cin,&cin_addr_len)) < 0)
{
perror("connect");
goto _error1;
}
/* 将分配成功的套接字newfd设置成非阻塞模式*/
int b_on = 1;
ioctl(newfd, FIONBIO, &b_on);//将分配成功的套接字newfd设置为非阻塞方式
sin_data.fd = newfd;
if(inet_ntop(AF_INET,&cin.sin_addr.s_addr,sin_data.ipv4_addr,sizeof(sin_data.ipv4_addr)) < 0)
{
perror("inet_ntop");
goto _error2;
}
sin_data.port = ntohs(cin.sin_port);
printf("get a new client->(ip:%s)(port:%d)(fd:%d)\n",sin_data.ipv4_addr,sin_data.port,sin_data.fd);
insert_end_linklist(fdlist,sin_data);//将建立客户端连接的fd加入列表
//show_linklist(fdlist);
}
else//有连接好的客户端发送了数据
{
//puts("22222222222222222222");
for(i=0;i<get_length_linklist(fdlist);i++)//将链表中的fd都处理一遍
{
sin_list = get_list_pos_linklist(fdlist,i);
sin_data = sin_list->data;
//printf("reading fd is ->(第 %d 个)(fd:%d)(ip:%s)(port:%d)\n",i,sin_data.fd,sin_data.ipv4_addr,sin_data.port);
if(sin_data.fd == fd)//不是建立连接后分配的newfd
continue ;
//puts("########read before");
bzero(buf,BUFSIZ);
do
{
ret = read(sin_data.fd,buf,BUFSIZ-1);
}while(ret < 0 && errno == EINTR);//阻塞读写
if(ret < 0)
{
//perror("read");
continue;
}
if(ret == 0)//对方已关闭
{
printf("client is existing!\n");
delete_locate_linklist(fdlist,sin_data);
continue;
}
printf("client ip(:%s) port(:%d) fd(:%d) receive data: %s",sin_data.ipv4_addr,sin_data.port,sin_data.fd,buf);
bzero(resp_buf,BUFSIZ+25);
strncpy(resp_buf,SERV_RESP_STR,strlen(SERV_RESP_STR));
strcat(resp_buf,"ip(");
strcat(resp_buf,sin_data.ipv4_addr);
char s_port[10];
strcat(resp_buf," port(");
sprintf(s_port,"%d",sin_data.port);
strcat(resp_buf,s_port);
strcat(resp_buf," data(");
strcat(resp_buf,buf);
do
{
ret = write(sin_data.fd,resp_buf,strlen(resp_buf));
}while(ret < 0 && EINTR == errno);
//puts("###############################");
if(strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)) == 0)
{
printf("client (fd:%d)(ip:%s)(potr:%d) is existing!\n",sin_data.fd,sin_data.ipv4_addr,sin_data.port);
delete_locate_linklist(fdlist,sin_data);//将退出的客户端的fd从列表中删除
close(sin_data.fd);
//show_linklist(fdlist);
}
}
}
}
}
}
_error2:
close(newfd);
_error1:
close(fd);
clear_linklist(fdlist);
}3、所使用头文件
#ifndef __NET_H__
#define __NET_H__
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/select.h>
#define SERV_IP_ADDR "192.168.3.112"
#define SERV_PORT 5003
#define BACKLOG 5
#define QUIT_STR "quite"
#define SERV_RESP_STR "Server:"
#endif
4、链表 支持 .c文件
#include "linklist.h"
linklist create_linklist(void)
{
linklist L;
if((L=(linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory!\n");
return NULL;
}
L->data.fd = 0;
bzero(L->data.ipv4_addr,sizeof(L->data.ipv4_addr));
L->data.port = 0;
L->next = NULL;
return L;
}
linklist create_n_linklist(void)
{
linklist L,H,r;
datatype x;
if((L=(linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory!\n");
return NULL;
}
L->data.fd = 0;
bzero(L->data.ipv4_addr,sizeof(L->data.ipv4_addr));
L->data.port = 0;
L->next = NULL;
r = L;
while(1)
{
printf("Please input a NUM_NL80211_WOWLAN_TRIGber(-1 exit :");
while(scanf("%d",&x.fd) != 1)
{
printf("Please INPUT_PROP_CNTut a number(-1 exit :");
getchar();
}
if(x.fd == -1)break;
if((H=(linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc nexto memmory!\n");
return L;
}
H->data = x;
H->next = NULL;
r->next = H;
r=H;
}
return L;
}
int delete_pos_linklist(linklist L,int pos)
{
linklist r,p;
int i=-1;
if(pos < 0 ||pos >=get_length_linklist(L))
{
printf("input pos is invalid!\n");
return -1;
}
r = L;
while(i < pos-1)
{
i++;
r = r->next;
}
if(r == NULL || r->next==NULL)
{
printf("argc is iavalid!\n");
return -1;
}
else
{
p = r->next;
r->next = p->next;
p->next = NULL;
free(p);
return 0;
}
}
int delete_locate_linklist(linklist L,datatype x)
{
linklist r,p;
if(L->next == NULL)
{
printf("list is NULL!\n");
return -1;
}
r = L;
while(r->next->data.fd != x.fd)
{
if(r->next == NULL)
{
printf("value is not in list!\n");
return -1;
}
r = r->next;
}
p = r->next;
r->next = p->next;
p->next = NULL;
free(p);
return 0;
}
void clear_linklist(linklist L)
{
while(get_length_linklist(L))
{
delete_pos_linklist(L,get_length_linklist(L)-1);
}
free(L);
L->next = NULL;
L = NULL;
}
int get_length_linklist(linklist L)
{
int i=0;
linklist r;
r = L;
while(r->next)
{
r = r->next;
i++;
}
return i++;
}
linklist get_list_pos_linklist(linklist L,int pos)
{
int i=0;
linklist r;
if(L->next == NULL)
{
printf("list is NULL!\n");
return NULL;
}
if(pos<0 || pos>=get_length_linklist(L))
{
printf("input is invalid!\n");
return NULL;
}
r = L->next;
while(i<pos)
{
r = r->next;
i++;
}
return r;
}
linklist get_list_locate_linklist(linklist L,datatype x)
{
linklist r;
if(L->next == NULL)
{
printf("list is NULL!\n");
return NULL;
}
r = L->next;
while(r->data.fd != x.fd)
{
if(r->next == NULL)
{
printf("value is not in list!\n");
return NULL;
}
r = r->next;
}
return r;
}
int insert_head_linklist(linklist L,datatype x)
{
linklist H;
if((H=(linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory\n");
return -1;
}
H->data = x;
H->next = L->next;
L->next = H;
return 0;
}
int insert_n_head_linklist(linklist L)
{
datatype x;
while(1)
{
printf("Please input a number(-1 exit:");
while(scanf("%d",&x.fd) != 1)
{
printf("Please input a number:(-1 exit");
getchar();
}
if(x.fd == -1)break;
insert_head_linklist(L,x);
}
return 0;
}
int insert_end_linklist(linklist L,datatype x)
{
linklist r,H;
if((H = (linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory!");
return -1;
}
r = L;
while(r->next)
{
r = r->next;
}
H->next = NULL;
H->data = x;
r->next = H;
return 0;
}
int insert_n_end_linklist(linklist L)
{
datatype x;
while(1)
{
printf("Please input a number(-1 exit:");
while(scanf("%d",&x.fd) != 1)
{
printf("Please input a number:(-1 exit");
getchar();
}
if(x.fd == -1)break;
insert_end_linklist(L,x);
}
return 0;
}
int insert_pos_linklist(linklist L,datatype x,int pos)
{
linklist K,r;
if(pos == 0)
{
r = L;
}
else
{
r = get_list_pos_linklist(L,pos-1);
}
if(r == NULL)
{
printf("argc is invalidateid!\n");
return -1;
}
else
{
if((K = (linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc no memmory!");
return -1;
}
K->data = x;
K->next = r->next;
r->next = K;
}
return 0;
}
int insert_order_linklist(linklist L,datatype x)
{
linklist r,H;
if((H = (linklist)malloc(sizeof(listnode))) == NULL)
{
printf("malloc nexto memmory!\n");
return -1;
}
H->data = x;
r = L;
while(r->next && r->next->data.fd < x.fd)
{
r = r->next;
}
H->next = r->next;
r->next = H;
return 0;
}
void reverse_linklist(linklist L)
{
linklist r,p;
if(L->next == NULL)
{
printf("list is NULL!\n");
return ;
}
r = L->next;
L->next = NULL;
while(r)
{
p = r;
r = r->next;
p->next = L->next;
L->next = p;
}
return ;
}
void sort_linklist(linklist L)
{
linklist r,p,q;
if(L == NULL)
{
printf("list is NULL!\n");
return ;
}
r = L->next;
L->next = NULL;
while(r)
{
p = r;
r = r->next;
q = L;
while(q->next && q->next->data.fd < p->data.fd)
{
q = q->next;
}
p->next = q->next;
q->next = p;
}
}
void show_linklist(linklist L)
{
printf("list is:\n");
if(L->next == NULL)
{
printf("\tlist is NULL!list\n");
return ;
}
while(L->next)
{
printf("\t%d %s %d\t",L->next->data.fd,L->next->data.ipv4_addr,L->next->data.port);
L = L->next;
puts("");
}
//puts("");
return ;
}
5、链表 支持 .h文件
#ifndef __SINGLE_LINKLIST_H__
#define __SINGLE_LINKLIST_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
typedef struct{
int fd;
char ipv4_addr[16];
int port;
}datatype;
typedef struct node{
datatype data;
struct node *next;
}listnode,*linklist;
linklist create_linklist(void);
linklist create_n_linklist(void);
int delete_pos_linklist(linklist L,int pos);
int delete_locate_linklist(linklist L,datatype x);
void clear_linklist(linklist L);
int get_length_linklist(linklist L);
linklist get_list_pos_linklist(linklist L,int pos);
linklist get_list_locate_linklist(linklist L,datatype x);
int insert_head_linklist(linklist L,datatype x);
int insert_n_head_linklist(linklist L);
int insert_end_linklist(linklist L,datatype x);
int insert_n_end_linklist(linklist L);
int insert_pos_linklist(linklist L,datatype x,int pos);
int insert_order_linklist(linklist L,datatype x);
void reverse_linklist(linklist);
void sort_linklist(linklist L);
void show_linklist(linklist L);
#endif
扫一扫
1270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
