Linux网络编程【五】：TCP协议高性能服务器(http)模型之I/O多路转接select

dup:





dup用来复制oldfd所指的文件描述符。但复制成功时返回最小的尚未被使用的文件描述符。若有错误则返回－1，错误代码存入errno中。返回的新文件描述符和参数oldfd指向同一个文件，共享所有的锁定，读写指针，和各项权限或标志位。

1.打开一个新文件

2.关掉标准输出文件符

3.调用dup给文件描述符

4.此时文件描述符变为1

5.将所要打印数据重定向到文件中

I/O多路转接之select

系统提供select函数来实现多路复用输入/输出模型。select系统调用是用来让我们的程序监视多个文件句柄的状态变化的。
select:该函数允许进程指示内核等待多个事件中的任何一个发生，并只在有一个或多个事件发生或经历一段指定的时间后才唤醒它。



参数意义：

nfds:待测试描述符个数。最大文件描述符+1

readfds/writefds/exceptfds：分别对应于需要检测的可读文件件描述符的集合，可写文件描述符的集 合及异常文件描述符的集合。

异常原因：

   1.某个套接字的带外数据的到达

   2.某个已置为分组模式的伪终端存在可从其主端读取的控制状态信息

select使用描述符集，通常是一个整形数组，其中每个整数中每一位对应一个描述符

其中四个宏：

下面的宏提供了处理这三种描述词组的方式:

FD_CLR(inr fd,fd_set* set)；用来清除描述词组set中相关fd 的位

FD_ISSET(int fd,fd_set *set)；用来测试描述词组set中相关fd 的位是否为真

FD_SET（int fd,fd_set*set）；用来设置描述词组set中相关fd的位

FD_ZERO（fd_set *set）；用来清除描述词组set的全部位

timeout:它告知内核等待所制定描述符中的任何一个就绪可在多长时间，其timeval结构用于指定这段时间的秒数和微妙数。

struct timeval

{

    long tv_sec;//seconds

    long tv_usec;//microseconds

}

有三种情况：

永远等待下去：仅在有一个描述符准备好I/O时才返回，为此，我们把该参数设为NULL.

等待固定时间：在有一个描述符准备好I/O时返回，但是不超过由该参数所指向的timeval结构中指定的秒数和微妙数。

根本不等待：检查描述符后立即返回，这称为轮询，为此该参数必须指向一个timeval结构，而且其中的定时器值必须为0；

前两种情形的等待通常会被进程在等待期间捕获的信号中断，并从信号处理函数返回。

注：有的Linux会在select函数返回时修改timeval结构，从移植性考虑，我们应假设timeval结构在函数返回时未定义，因而每次调用select前都得对它进行初始化。

函数返回值：

执行成功则返回文件描述词状态已改变的个数

如果返回0代表在描述词状态改变前已超过timeout时间，没有返回；

当有错误发生时则返回-1， 错误原因存于errno，此时参数readfds，writefds，exceptfds和timeout的值变成不可预测。错误值可能为：

EBADF 文件描述词为无效的或该文件已关闭

EINTR 此调用被信号所中断

EINVAL 参数n 为负值。

ENOMEM 核心内存不足

select和多进程/多线程优缺点比较：

多进程/线程方法的优点：

每个独立进程处理一个独立的client，对server进程来说只需要accept新的连接，对每个子进程来说只需要处理自己的client即可。

多进程、线程方法的缺点：

子进程的创建需要独立的父进程资源副本，开销较大，对高并发的请求不太适合；且一个进程仅处理一个client不能有效发挥作用。另外有些情况下还需要进程间进行通信以协调各进程要完成的任务。

select

优点：相比起多进程/线程 缩短了等待时间，提高效率，减少进程占用内存开销

缺点：

（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大

（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大

（3）select支持的文件件描述符数量太小了，默认是1024

使用select实现服务器代码：

#include<stdio.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<string.h>

int array_fds[1024];

static void Usage(char* proc)
{
printf("Usage: %s [local_ip] [local_port]", proc);
}

int startup(char* _ip, int _port)
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0)
{
perror("socket");
return 2;
}

int flg = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &flg, sizeof(flg));

struct sockaddr_in local;
local.sin_family = AF_INET;
local.sin_port = htons(_port);
local.sin_addr.s_addr = inet_addr(_ip);

if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
{
perror("bind");
return 3;
}

if(listen(sock, 5) < 0)
{
perror("listen");
return 0;
}
return sock;
}

int main(int argc, char* argv[])
{
if(argc != 3)
{
Usage(argv[0]);
return 1;
}

int listen_socket = startup(argv[1], atoi(argv[2]));

fd_set rfds;
int max_fd = 0;
int array_size = sizeof(array_fds)/sizeof(array_fds[0]);
array_fds[0] = listen_socket;
int i = 0;
for(i = 1; i < array_size; i++)
{
array_fds[i] = -1;
}
while(1)
{
max_fd = -1;
struct timeval timeout = {0,0};
FD_ZERO(&rfds);
for(i = 0; i < array_size; i++)
{
if(array_fds[i] > 0)
{
FD_SET(array_fds[i], &rfds);
if(array_fds[i] > max_fd)
{
max_fd = array_fds[i];
//printf("i:%d,  %d\n",i,max_fd);
}
}
}

switch(select(max_fd+1, &rfds, NULL,/*&rfds,*/ NULL, NULL))
{
case 0:
printf("timeout...\n");
break;
case -1:
perror("select");
break;
default:
{
//printf("select sus\n");
int k = 0;
for(;k < array_size; k++)
{
if(array_fds[k] < 0)
continue;

//	printf("k = %d, array_fds[k] : %d\n",k,array_fds[k]);
if(k == 0 && FD_ISSET(array_fds[k], &rfds))
{
//	printf(" Accept\n");
struct sockaddr_in client;
socklen_t len = sizeof(client);
int new_sock = accept(array_fds[k], (struct sockaddr*)&client, &len);
if(new_sock < 0)
{
perror("accept");
continue;
}
else
{
printf("get a client : %s ,  %d \n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
int j = 1;
for(;j < array_size;j++)
{
if(array_fds[j] < 0)
{
array_fds[j] = new_sock;
break;
}
}
if(j == array_size)
close(new_sock);
//	printf("j:%d\n",j);
//	printf("array_fds[1]:%d\n",array_fds[j]);
}
}
else if(k != 0 && FD_ISSET(array_fds[k],&rfds))
{
//	printf("input\n");
char buf[10240];
ssize_t s = read(array_fds[k], buf, sizeof(buf)-1);
if(s > 0)
{
buf[s] = 0;
printf("client say# %s \n", buf);
write(array_fds[k], buf, strlen(buf));
}
else if(s == 0)
{
printf("client quit ...\n");
close(array_fds[k]);
array_fds[k] = -1;
}
else
{
perror("read");
close(array_fds[k]);
array_fds[k] = -1;
}
}
else
{
}
}

}
break;
}
}
return 0;
}

客户端代码：

#include<stdio.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<string.h>
#include<strings.h>
#include<sys/stat.h>
#include<unistd.h>
static void Usage(char * proc)
{
printf("Usage : %s [ip] [port]\n");
}

int main(int argc, char* argv[])
{
if(argc != 3)
{
Usage(argv[0]);
return 1;
}

int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in peer;
peer.sin_family = AF_INET;
peer.sin_port = htons(atoi(argv[2]));
peer.sin_addr.s_addr = inet_addr(argv[1]);

if(connect(sock, (struct sockaddr*)&peer, sizeof(peer)) < 0)
{
perror("connect");
return 2;
}

char buf[10240];
//int sfd = dup(STDOUT_FILENO);
while(1)
{
printf("Please Enter : ");
fflush(stdout);
ssize_t s = read(0, buf, sizeof(buf)-1);
int sfd = dup(STDOUT_FILENO);
if(s > 0)
{
buf[s-1] = 0;
//write(sock, buf, strlen(buf));
//输出重定向
//close(1);
// int new_fd = dup(sock);
int new_fd = dup2(sock, 1);
if(new_fd == -1)
{
perror("dup()");
return -1;
}
printf("%s",buf);
fflush(stdout);
//恢复stdout
dup2(sfd, STDOUT_FILENO);

ssize_t _s = read(sock, buf, sizeof(buf)-1);
if(_s > 0)
{
buf[_s] = 0;
printf("sever # %s \n", buf);
}
}
}
close(sock);
return 0;
}