异步请求池的实现

同步异步与阻塞非阻塞

首先弄清同步异步与阻塞非阻塞的区别。同步异步是形容两者的关系，是机制。同步是一请求一返回，相当于串行工作；而异步是请求之后不需等待结果返回，继续做其他操作的，只管发送请求，不需要等待结果，相当于并行工作。阻塞非阻塞是fd的状态，是特性。是fd数据未准备好时是否立即返回的问题。同步异步与阻塞非阻塞没有必然联系。

异步请求池的做法

1.异步请求用多个连接（即多个fd）。
2.基于网络IO发送对应的协议。
3.多个连接：当发送完请求后，在未返回结果之前，这个fd不能释放，需要存放在epoll中，监听读事件，由epoll进行管理。
4.非阻塞：由于fd设置非阻塞，send()和recv()，即请求与响应数据，不能做到同一个线程中，因为这些异步接口是提供给外部使用的。

异步请求池的设计

异步请求池的设计有个套路，一共有四步。

1.init

初始化异步操作的上下文。有两个操作，epoll_create()和开一个线程用于recv_cb。这里上下文是指epfd和线程id。

2.commit

先建立连接，组织好对应的协议，再send()发送到对应的服务器，然后将该fd加入epoll，监听可读状态。

3.线程入口函数callback()

epoll_wait()，监听哪些fd可读，recv(fd)，读出所有的数据并解析。

4.destroy()关闭和回收资源

close(epfd)，pthread_cancel()
下面以DNS请求为例

static void* dns_async_client_proc(void *arg) 
{
	struct async_context *ctx = (struct async_context*)arg;
	int epfd = ctx->epfd;
	while (1) 
{
		struct epoll_event events[ASYNC_CLIENT_NUM] = {0};
		int nready = epoll_wait(epfd, events, ASYNC_CLIENT_NUM, -1);
		if (nready < 0) 
        {
			if (errno == EINTR || errno == EAGAIN) 
            {
				continue;
			} else 
            {
				break;
			}
		} else if (nready == 0) 
        {
			continue;
		}
		printf("nready:%d\n", nready);
		int i = 0;
		for (i = 0;i < nready;i ++) 
        {

			struct ep_arg *data = (struct ep_arg*)events[i].data.ptr;
			int sockfd = data->sockfd;
			char buffer[1024] = {0};
			struct sockaddr_in addr;
			size_t addr_len = sizeof(struct sockaddr_in);
			int n = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr, (socklen_t*)&addr_len);
			struct dns_item *domain_list = NULL;
			int count = dns_parse_response(buffer, &domain_list);
			data->cb(domain_list, count); //call cb
			int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
			//printf("epoll_ctl DEL --> sockfd:%d\n", sockfd);
			close(sockfd); 
			dns_async_client_free_domains(domain_list, count);
			free(data);
		}
	}
}

//dns_async_client_init()
//epoll init
//thread init
struct async_context *dns_async_client_init(void) 
{
	int epfd = epoll_create(1); // 
	if (epfd < 0) return NULL;
	struct async_context *ctx = calloc(1, sizeof(struct async_context));
	if (ctx == NULL) 
    {
		close(epfd);
		return NULL;
	}
	ctx->epfd = epfd;
	pthread_t thread_id;
	int ret = pthread_create(&thread_id, NULL, dns_async_client_proc, ctx);
	if (ret) 
    {
		perror("pthread_create");
		return NULL;
	}
	usleep(1); //child go first
	return ctx;
}

//dns_async_client_commit(ctx, domain)
//socket init
//dns_request
//sendto dns send
int dns_async_client_commit(struct async_context* ctx, const char *domain, async_result_cb cb) 
{
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0) 
    {
		perror("create socket failed\n");
		exit(-1);
	}
	printf("url:%s\n", domain);
	set_block(sockfd, 0); //nonblock
	struct sockaddr_in dest;
	bzero(&dest, sizeof(dest));
	dest.sin_family = AF_INET;
	dest.sin_port = htons(53);
	dest.sin_addr.s_addr = inet_addr(DNS_SVR);
	int ret = connect(sockfd, (struct sockaddr*)&dest, sizeof(dest));
	//printf("connect :%d\n", ret);
	struct dns_header header = {0};
	dns_create_header(&header);
	struct dns_question question = {0};
	dns_create_question(&question, domain);
	char request[1024] = {0};
	int req_len = dns_build_request(&header, &question, request);
	int slen = sendto(sockfd, request, req_len, 0, (struct sockaddr*)&dest, sizeof(struct sockaddr));
	struct ep_arg *eparg = (struct ep_arg*)calloc(1, sizeof(struct ep_arg));
	if (eparg == NULL) return -1;
	eparg->sockfd = sockfd;
	eparg->cb = cb;

	struct epoll_event ev;
	ev.data.ptr = eparg;
	ev.events = EPOLLIN;
	ret = epoll_ctl(ctx->epfd, EPOLL_CTL_ADD, sockfd, &ev); 
	//printf(" epoll_ctl ADD: sockfd->%d, ret:%d\n", sockfd, ret);
	return ret;	
}

static void dns_async_client_result_callback(struct dns_item *list, int count) 
{
	int i = 0;
	for (i = 0;i < count;i ++) 
    {
		printf("name:%s, ip:%s\n", list[i].domain, list[i].ip);
	}
}

这里需要提示几点。一是为了避免主线程退出，导致数据接收不完整，可以在main函数中添加getchar()函数阻塞住。第二是全局变量尽量少用，因为全局变量难维护，可读性不强。第三，epoll不是TCP的专属产物，这里DNS虽然是UDP，但一样可以用epoll，因为epoll是基于fd做的，不是只有基于网络的IO才能用epoll，所以UDP、eventfd、timerfd等等，都可以用epoll。第四，数据接收完后，可以关闭fd，并且EPOLL_CTL_DEL，也可以复用fd，EPOLL_CTL_MOD监听可写事件，为下次数据发送做准备，如果fd长时间没有用，要做超时管理，否则服务端可能会主动断开连接，一般有两种做法，一是定时发送心跳包，二是发现用不了，就在下次send()时关闭fd，再重新分配一个fd。这两种做法成本都很低，都可行。最后，代码中有个问题，如果服务器没有数据返回，那么epoll就不会触发对应fd的读事件，fd就不会close()，所以需要加入fd定时器（timerfd），超时就重发。