版权声明： https://blog.csdn.net/Set_Mode/article/details/90376737

文章目录

• IO模型
• 阻塞I/O 模式
• 读阻塞-以read函数为例：
• 写阻塞

非阻塞模式I/O

• 非阻塞模式的实现

多路复用I/O

• select() 实现多路复用

TCP多路复用

IO复用select()示例

• 头文件
• Server.c
• Client.c

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

读阻塞-以read函数为例：

进程调用read函数从套接字上读取数据，当套接字的接收缓冲区中还没有数据可读，函数read将发生阻塞。
它会一直阻塞下去，等待套接字的接收缓冲区中有数据可读。
经过一段时间后，缓冲区内接收到数据，于是内核便去唤醒该进程，通过read访问这些数据。
如果在进程阻塞过程中，对方发生故障，那这个进程将永远阻塞下去。

写阻塞

• 在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入的数据量的情况下。
• 这时，写操作不进行任何拷贝工作，将发生阻塞。
• 一量发送缓冲区内有足够的空间，内核将唤醒进程，将数据从用户缓冲区中拷贝到相应的发送数据缓冲区。
• UDP不用等待确认，没有实际的发送缓冲区，所以UDP协议中不存在发送缓冲区满的情况，在UDP套接字上执行的写操作永远都不会阻塞。

非阻塞模式I/O

• 当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O 操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。”
• 当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环来不停地测试是否一个文件描述符有数据可读（称做polling）。
• 应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。
• 这种模式使用中不普遍。
• 

非阻塞模式的实现

fcntl()函数
当你一开始建立一个套接字描述符的时候，系统内核将其设置为阻塞IO模式。
可以使用函数fcntl()设置一个套接字的标志为O_NONBLOCK 来实现非阻塞。
代码实现；

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

• 应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的；
• 若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；
• 若设置多个进程，分别处理一条数据通路，将新产生进程间的同步与通信问题，使程序变得更加复杂；
• 比较好的方法是使用I/O多路复用。其基本思想是：
  先构造一张有关描述符的表，然后调用一个函数。当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回。
  函数返回时告诉进程那个描述符已就绪，可以进行I/O操作。
• 多路复用不止针对套接字fd，也针对普通的文件描述符fd

select() 实现多路复用

#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);

select()参数

• maxfd
  所有监控的文件描述符中最大的那一个加1
• read_fds
  所有要读的文件文件描述符的集合
• write_fds
  所有要的写文件文件描述符的集合
• except_fds
  其他要向我们通知的文件描述符
• timeout
  超时设置.
  Null：一直阻塞，直到有文件描述符就绪或出错
  时间值为0：仅仅检测文件描述符集的状态，然后立即返回
  时间值不为0：在指定时间内，如果没有事件发生，则超时返回。

1. 在我们调用select时进程会一直阻塞直到以下的一种情况发生.

• 有文件可以读.
• 有文件可以写.
• 超时所设置的时间到.

1. 为了设置文件描述符我们要使用几个宏：

• FD_SET 将fd加入到fdset
• FD_CLR 将fd从fdset里面清除
• FD_ZERO 从fdset中清除所有的文件描述符
• FD_ISSET 判断fd是否在fdset集合中

1. 宏的形式:

   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)

TCP多路复用

TCP多路复用I/O	关键点
	1. select( )函数里面的各个文件描述符fd_set集合的参数在select( )前后发生了变化 前：表示关心的文件描述符集合 后：有数据的集合（如不是在超时还回情况下）2.kernel使fd_set集合发生了变化 3.若是监听套接字上有数据，则有新客户端连接，就去调用accept()函数 4. 若是已建立连接的套接字上有数据，则去读数据

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*/
#if 0
select(maxfd+1,&rset,NULL,NULL,NULL);
#else
struct timeval tout;
tout.tv_sec = 5;
tout.tv_usec = 0;
select(maxfd+1,&rset,NULL,NULL,&tout);
#endif
int newfd;
if(FD_ISSET(fd,&rset))//依次判断
{
newfd = accept(fd,...);//若是监听套接字上有数据，则有新客户端连接，就去调用accept()函数
}

/* 若是已建立连接的套接字上有数据，则去读数据 */
/* ... */

}

}

IO复用select()示例

头文件

#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.2.246"
#define BACKLOG 5

#define QUIT_STR "quit"
#define SERV_RESP_STR "SERVER:"
#endif

Server.c

#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);

}

Client.c

/*./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);
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);
do {
ret = read (0, buf, BUFSIZ - 1);
} 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);
}