前面介绍的函数如recv、send、read和write等函数都是阻塞性函数,若资源没有准备好,则调用函数的进程进入阻塞状态,使用fcntl函数可以实现IO的非阻塞,也就是所谓的IO多路转换。
主线程负责接收客户端请求,收到请求后将对应的套接字描述符存放在动态数组中,一个子线程负责遍历该套接字描述符的动态数组,并处理对应套接字的客户端请求。
动态数组头文件vector_fd.h:
#ifndef __VECTOR_H__
#define __VECTOR_H__
typedef struct
{
int *fd; //套接字描述符的指针
int counter; //当前套接字描述符的个数
int max_counter; //套接字描述符的最大存放个数
}VectorFD;
extern VectorFD* create_vector_fd(void);
extern void destroy_vector_fd(VectorFD *);
extern int get_fd(VectorFD *, int index);
extern void remove_fd(VectorFD *, int fd);
extern void add_fd(VectorFD *, int fd);
#endif
动态数组源文件vector_fd.cpp
#include "vector_fd.h"
#include <malloc.h>
#include <assert.h>
#include <stdlib.h>
#include <memory.h>
/*扩展动态数组*/
static void encapacity(VectorFD *vfd)
{
//动态数组的数量大于动态数组的最大值
if (vfd->counter >= vfd->max_counter)
{
//默认每次扩展5个
int *fds = (int*)calloc(vfd->counter + 5, sizeof(int));
assert(fds != NULL);
//将原来动态数组的内容拷贝到新的动态数组中
memcpy(fds, vfd->fd, sizeof(int) * vfd->counter);
//销毁原来套接字描述符的动态数组
free(vfd->fd);
//新的动态数组赋值
vfd->fd = fds;
//动态数组最大容量重置
vfd->max_counter += 5;
}
}
/*获取套接字描述符的索引*/
static int indexof(VectorFD *vfd, int fd)
{
int i = 0;
for (; i < vfd->counter; i++)
{
if (vfd->fd[i] == fd)
return i;
}
//没有找到返回-1
return -1;
}
/*创建动态数组*/
VectorFD* create_vector_fd(void)
{
VectorFD *vfd = (VectorFD*)calloc(1, sizeof(VectorFD));
assert(vfd != NULL);
//创建存放套接字描述符的动态数组
vfd->fd = (int*)calloc(5, sizeof(int));
assert(vfd != NULL);
vfd->counter = 0;
vfd->max_counter = 0;
return vfd;
}
/*释放动态数组*/
void destroy_vector_fd(VectorFD *vfd)
{
assert(vfd != NULL);
free(vfd->fd);
free(vfd);
}
/*根据索引获取套接字描述符*/
int get_fd(VectorFD *vfd, int index)
{
assert(vfd != NULL);
if (index < 0 || index > vfd->counter - 1)
return 0;
return vfd->fd[index];
}
/*删除指定的套接字描述符*/
void remove_fd(VectorFD *vfd, int fd)
{
assert(vfd != NULL);
//获取套接字描述符的索引
int index = indexof(vfd, fd);
int i = index;
//将索引后面的套接字描述符向前移动一个位置
for (; i < vfd->counter - 1; i++)
{
vfd->fd[i] = vfd->fd[i + 1];
}
//数量减一
vfd->counter--;
}
/*将套接字描述符添加到套接字描述符的动态数组中*/
void add_fd(VectorFD * vfd, int fd)
{
assert(vfd != NULL);
//扩展动态数组
encapacity(vfd);
vfd->fd[vfd->counter++] = fd;
}
服务器代码:
#include <netdb.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>
#include <memory.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <pthread.h>
#include "vector_fd.h"
#include <fcntl.h>
VectorFD *vfd;
int sockfd;
/*信号处理函数*/
void sig_handler(int signo)
{
if (signo == SIGINT)
{
printf("server close!\n");
/*关闭socket*/
close(sockfd);
/*销毁动态数组*/
destroy_vector_fd(vfd);
exit(1);
}
}
//fd对应某个连接的客户端,和某个连接的客户端进行通信(非阻塞)
void do_service(int fd)
{
/*与客户端进行读写操作*/
char buff[512];
memset(buff, 0, sizeof(buff));
//采用非阻塞方式,读不到数据直接返回,直接服务下一个客户端,
//不需要判断小于0的情况
size_t size = read(fd, buff, sizeof(buff));
if (size == 0)
{
//客户端已经关闭连接
char info[] = "client closed";
//不建议用标准IO,因为标准IO有缓存功能
write(STDOUT_FILENO, info, sizeof(info));
//删除动态数组中的fd,
remove_fd(vfd, fd);
//关闭对应客户端的socket
close(fd);
}
else if(size > 0)
{
write(STDOUT_FILENO, buff, sizeof(buff));
if (write(fd, buff, size) < 0)
{
//假如客户端关闭,
if (errno == EPIPE)
{
perror("write error");
remove_fd(vfd, fd);
close(fd);
}
}
}
}
/*线程函数*/
void* th_fn(void *arg)
{
int i = 0;
while (1)
{
i = 0;
//遍历动态数组中的socket描述符
for (; i < vfd->counter; i++)
{
do_service(get_fd(vfd, i));
}
}
return (void*)0;
}
void out_addr(struct sockaddr_in *clientaddr)
{
char ip[16];
memset(ip, 0, sizeof(ip));
int port = ntohs(clientaddr->sin_port);
inet_ntop(AF_INET, &clientaddr->sin_addr.s_addr, ip, sizeof(ip));
printf("%s(%d) connected!\n", ip, port);
}
int main(int argc, char* argv[])
{
/*输入端口号*/
if (argc < 2)
{
printf("usage: %s #port\n", argv[0]);
exit(1);
}
/*注册SIFINT信号SIGINT,“ctrl + c”终止程序运行*/
if (signal(SIGINT, sig_handler) == SIG_ERR)
{
perror("signal sigint error");
exit(1);
}
/*1.创建socket
* 注:socket创建在内核中,是一个结构体
* AF_INET:IPV4
* SOCK_STREAM:tcp协议
* */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1)
{
perror("socket error");
exit(1);
}
/*2.将socket和地址(ip、port)进行绑定*/
struct sockaddr_in serveraddr;
memset(&serveraddr, 0, sizeof(serveraddr));
//地址中填入ip、port、internet地质族类型
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons((uint16_t)atoi(argv[1]));//转换为网络字节序
serveraddr.sin_addr.s_addr = htons(INADDR_ANY);//响应所有的网卡请求
if (bind(sockfd, (struct sockaddr*)(&serveraddr), sizeof(serveraddr)) < 0)//注意地址要强制转换为通用地址
{
perror("bind error");
exit(1);
}
/*3.调用listen函数启动监听(指定的端口监听)
* 通知系统去接收来自客户端的连接请求
* (将接收到的客户端的请求放置到对应的队列中)
*第二个参数:指定队列的长度
* */
if (listen(sockfd, 10) < 0)
{
perror("listen error");
exit(1);
}
/*创建存放套接字描述符的动态数组*/
vfd = create_vector_fd();
pthread_t th;
int err;
/*设置线程的分离属性*/
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
//以分离状态启动子进程
if ((err = pthread_create(&th, &attr, th_fn, (void*)0)) != 0)
{
perror("pthread create error");
}
//主控线程销毁线程属性
pthread_attr_destroy(&attr);
/*
* 1)主控线程获得客户端的连接,将新的socket描述符放置到动态数组中;
* 2)启动的子线程负责遍历动态数组的socket描述符并和对应的客户端进行通信(采用非阻塞的读写)
*/
struct sockaddr_in clientaddr;
socklen_t len = sizeof(clientaddr);
while (1)
{
//主控线程负责调用accept去获得客户端的连接
int fd = accept(sockfd, (struct sockaddr*)&clientaddr, &len);
if (fd < 0)
{
perror("accept error");
continue;
}
out_addr(&clientaddr);
//将读写修改为非阻塞方式
int var;
//获得原来套接字状态标志,放在var中
fcntl(fd, F_GETFL, &var);
var |= O_NONBLOCK; //在原来状态标志基础上添加非阻塞标志
fcntl(fd, F_SETFL, var);//设置非阻塞
//将返回的新的套接字描述符加入到动态数组中
add_fd(vfd, fd);
}
return 0;
}
客户端代码可参考之前博文的代码。