网络编程（三）

IO模型（一个应用程序可以服务于多个IO操作）

Linux内核提供了四种IO模型：

1. 阻塞IO
2. 非阻塞IO
3. IO多路复用
4. 异步IO

阻塞IO

进程调用阻塞IO函数，去获取数据或写数据，若没有数据提供或写缓冲区已满，阻塞IO函数就会阻塞当前进程

当对方有数据提供或写缓冲区有空间recv/write函数就会得到执行,当前进程就会被唤醒，继续执行。

非阻塞IO

进程调用非阻塞IO函数，去获取数据或写数据，若没有数据提供或写缓冲区已满，该函数会返回一个非正确的值，当前进程不会被阻塞

思考：如何设置非阻塞IO？

使用fcntl()函数
当你一开始建立一个套接字描述符的时候，系统内核将其设置为阻塞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); //将新的flag作用给文件描述符的状态标志

案例：设置套接字从阻塞IO为非阻塞IO模式

IO多路复用

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

集合表定为1024bit(一个进程最多可以打开1024个文件)

思想分三步：

1. 构建一张文件描述符集合表，表的大小1024bit，每一个bit位表示一个文件描述符所对应的IO通道是否有数据，若有数据，该bit位为1，若没有数据，该bit位为0.
2. 使用**select()**函数监控指定范围的文件描述符对应的IO通道，是否有数据发生；如果有数据，返回有几路通道有数据同时更新相应bit位置为1，其他bit位置为0；否则，一直阻塞等待.
3. 对文件描述符集合表的置位结果做出判断和响应。使用宏函数FD_ISSET(fd, &stFdr)；返回值如果是true，则要响应对应文件描述符的IO操作.如果没有被置位，则不处理。

select

select：监控文件描述符对应的IO通道是否有数据发生并记录到文件描述集合表中
调用select时进程会一直阻塞直达以下的一种情况发生：

1. 有文件可以读
2. 有文件可以写
3. 超时设置的时间到

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
//参数1：需要监控的最大文件描述符的个数，总数
//参数2：指针指向读文件描述符集合表
//参数3：指针指向写文件描述符集合表
//参数4：指针指向异常文件描述符集合表
//参数5：NULL—>将select变成阻塞函数
//返回值：成功返回监控到的有数据发生的通道个数；没有活跃则没有返回，则一直阻塞

参数5：timeout：超时设置
NULL：一直阻塞，直到有文件描述符就绪或出错
时间值为0：仅仅检测文件描述符集的状态，然后立即返回
时间值不为0：在指定时间内，如果没有事件发生，则超时返回。
struct timeval {
long tv_sec; /* seconds /
long tv_usec; / microseconds */
};

设置文件描述符使用的宏：

设置文件描述符使用的宏
void FD_ZERO(fd_set *fdset) //从fdset中清除所有的文件描述符
void FD_SET(int fd, fd_set *fdset) //将fd加入到fdset
void FD_CLR(int fd, fd_set *fdset) //将fd从fdset里清除
void FD_ISSET(int fd, fd_set *fdset) //判断fd是否在fdset集合中，发生变化，发生返回true

server

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#define BUF_SIZE 20
//tcp multiplexing
int main()
{
	//socket
	int serverfd = socket(AF_INET, SOCK_STREAM,0);
	//判断socket返回值
	if(-1 == serverfd)
	{
		perror("socket error");
		return -1;
	}
	//创建软通道成功
	printf("socket ok------\r\n");
	//bind
	struct sockaddr_in stserver;
	stserver.sin_family = AF_INET;
	stserver.sin_port = htons(8888);
	stserver.sin_addr.s_addr = inet_addr("127.0.0.1");
	int ret = bind(serverfd, (struct sockaddr*)&stserver, sizeof(struct sockaddr));
	//判断的返回值
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("bind error");
		return -1;
	}
	//绑定服务端主机成功
	printf("bind ok------\r\n");
	//listen
	ret = listen(serverfd, 5);
	//返回值判断
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("listen error");
		return -1;
	}
	//监听创建成功
	printf("listen ok------\r\n");
	//接受客户端的信息
	struct sockaddr_in stclient;
	//结构体大小
	socklen_t len = sizeof(struct sockaddr);
	//创建收发数据的缓冲区
	char buf[BUF_SIZE] = {0};

	//文件描述集合表
	fd_set stFdr;
	//清零
	FD_ZERO(&stFdr);

	while(1)
	{
		//select
		FD_SET(serverfd, &stFdr);
		FD_SET(0, &stFdr);
		ret = select(serverfd+1, &stFdr, NULL, NULL, NULL);
		if(ret < 0)
		{
			continue;
		}
		printf("select ok ret=%d\r\n", ret);

		//FD_ISSET
		if(FD_ISSET(0, &stFdr))
		{
			memset(buf, 0, BUF_SIZE);
			printf("please data:\r\n");
			fgets(buf, BUF_SIZE, stdin);
			printf("fgets data:%s\r\n", buf);
		}

		if(FD_ISSET(serverfd, &stFdr))
		{
			int newfd = accept(serverfd, (struct sockaddr*)&stclient, &len);
			if(-1 == newfd)
			{
				continue;
			}
			printf("accept ok\r\n");
			//recv
			ret = recv(newfd, buf, BUF_SIZE, 0);
			printf("recv:%s\r\n", buf);
			//send
			send(newfd, buf, BUF_SIZE, 0);
			printf("send data:%s\r\n", buf);
			close(newfd);

		}

	}
	return 0;
}

client

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define BUF_SIZE 20
//功能：TCPclient
int main()
{
	//socket
	int clientfd = socket(AF_INET, SOCK_STREAM, 0);
	//判断socket返回值
	if(-1 == clientfd)
	{
		//返回值为-1，代表创建软通道出错，打印出错原因并返回
		perror("socket error");
		return -1;
	}
	//创建软通道成功
	printf("socket ok----\r\n");
	//connect
	struct sockaddr_in serveraddr;
	//使用struct sockaddr_in结构体接受参数2的参数并强转为struct sockaddr结构体
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(8888);
	serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	int ret = connect(clientfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));
	//判断connect的返回值
	if(-1 == ret)
	{
		//失败打印失败原因并返回
		perror("connect error----\r\n");
		return -1;
	}
	//连接服务端成功
	printf("connect ok....\r\n");
	//创建数据缓冲区
	char buf[BUF_SIZE] = {0};
	//while(1)
	//{
		printf("please write:\r\n");
		//从标准输入端口输入数据，存储在buf里
		fgets(buf, BUF_SIZE, stdin);
		//send为发送数据
		ret = send(clientfd, buf, BUF_SIZE, 0);
		//返回值判断
		if(-1 == ret)
		{
			//失败返回原因，不做返回，接受服务端的数据
			perror("send error");
		}
		//清空接收数据的缓冲区
		memset(buf, 0, BUF_SIZE );
		//recv接收数据
		ret = recv(clientfd, buf, BUF_SIZE, 0);
		//返回值判断
		if(-1 == ret)
		{
			//失败返回原因并返回
			perror("recv error");
			return -1;
		}
		//成功打印接受的数据
		printf("recv data : %s\r\n", buf);
	//}
	//关闭软通道描述符
	close(clientfd);
	return 0;	
}

IO多路复用的总结：
两次拷贝：
第一次拷贝：调用select时，将位图表从用户空间拷贝一份到内核空间
第二次拷贝：select处理完毕所有就绪的描述符之后，将含有就绪描述符的位图表从内核空间拷贝回用户空间
两次遍历：
第一次遍历：在内核空间，内核针对位图表按位进行遍历（检索就绪的描述符并置1的过程）
第二次遍历：在用户空间，用户进程按照返回的位图表进行遍历（查找谁就就绪，就处理谁）