• 异步DNS的实现

    目录

    1. 同步和异步是什么？

    2. 为什么异步比同步快？

    3. 设计一个异步的框架(异步DNS)

    框架组成

    1. Init_ctx

    2. Commit

    3. Thread_callback  

    4. Destroy_ctx()

     完整代码

    运行效果

    3. 总结

    什么是协程？

    1. 同步和异步是什么？

    同步：执行一个操作之后，等待结果，然后才继续执行后续的操作。

    异步：执行一个操作后，可以去执行其他的操作，然后等待通知再回来执行刚才没执行完的操作。

    阻塞：进程给CPU传达一个任务之后，一直等待CPU处理完成，然后才执行后面的操作。

    非阻塞：进程给CPU传达任我后，继续处理后续的操作，隔断时间再来询问之前的操作是否完成。这样的过程其实也叫轮询。

    2. 为什么异步比同步快？

    同步要发起请求后，等待结果返回后再发送下一个请求。（串行）

    异步不用等待结果返回，一直发送请求。相当于一起发送，一起返回（并行）

     

    3. 设计一个异步的框架(异步DNS)

    框架组成

    1. Init_ctx();  epoll_create pthread_create
    2. Commit();
    3. Thread_callback();  线程检测IO是否可读
    4. Destroy_ctx(); 销毁

    1. Init_ctx

    epoll初始化，线程的初始化

    1. struct async_context *dns_async_client_init(void) {
    2.  
    3. 	int epfd = epoll_create(1); // 
    4. 	if (epfd < 0) return NULL;
    5.  
    6. 	struct async_context *ctx = calloc(1, sizeof(struct async_context));
    7. 	if (ctx == NULL) {
    8. 		close(epfd);
    9. 		return NULL;
    10. 	}
    11. 	ctx->epfd = epfd;
    12.  
    13. 	pthread_t thread_id;
    14. 	int ret = pthread_create(&thread_id, NULL, dns_async_client_proc, ctx);
    15. 	if (ret) {
    16. 		perror("pthread_create");
    17. 		return NULL;
    18. 	}
    19. 	usleep(1); //child go first
    20.  
    21. 	return ctx;
    22. }

    2. Commit

            主要工作的创建socket、dns协议的封装，然后发送UDP请求给DNS服务器，将sockfd加入epoll监控。

    1. //dns_async_client_commit(ctx, domain)
    2. //socket init
    3. //dns_request
    4. //sendto dns send
    5. int dns_async_client_commit(struct async_context* ctx, const char *domain, async_result_cb cb) {
    6.  
    7. 	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    8. 	if (sockfd < 0) {
    9. 		perror("create socket failed\n");
    10. 		exit(-1);
    11. 	}
    12.  
    13. 	printf("url:%s\n", domain);
    14.  
    15. 	//设置为非阻塞
    16. 	set_block(sockfd, 0); //nonblock
    17.  
    18. 	struct sockaddr_in dest;
    19. 	bzero(&dest, sizeof(dest));
    20. 	dest.sin_family = AF_INET;
    21. 	dest.sin_port = htons(53);
    22. 	dest.sin_addr.s_addr = inet_addr(DNS_SVR);
    23. 	
    24. 	int ret = connect(sockfd, (struct sockaddr*)&dest, sizeof(dest));
    25. 	//printf("connect :%d\n", ret);
    26.  
    27. 	struct dns_header header = {0};
    28. 	dns_create_header(&header); //填充 header
    29.  
    30. 	struct dns_question question = {0};
    31. 	dns_create_question(&question, domain); //填充 question
    32.  
    33. 	char request[1024] = {0};
    34. 	int req_len = dns_build_request(&header, &question, request); //准备请求头
    35. 	int slen = sendto(sockfd, request, req_len, 0, (struct sockaddr*)&dest, sizeof(struct sockaddr));
    36.  
    37. 	struct ep_arg *eparg = (struct ep_arg*)calloc(1, sizeof(struct ep_arg));
    38. 	if (eparg == NULL) return -1;
    39. 	eparg->sockfd = sockfd;
    40. 	eparg->cb = cb;
    41.  
    42. 	//加入epoll
    43. 	struct epoll_event ev;
    44. 	ev.data.ptr = eparg;
    45. 	ev.events = EPOLLIN;
    46. 	ret = epoll_ctl(ctx->epfd, EPOLL_CTL_ADD, sockfd, &ev); 
    47. 	//printf(" epoll_ctl ADD: sockfd->%d, ret:%d\n", sockfd, ret);
    48. 	return ret;
    49. }

    3. Thread_callback  

            线程检测IO是否可读，解析DNS应答，打印IP信息。

    1. //dns_async_client_proc()
    2. //epoll_wait
    3. //result callback
    4. static void* dns_async_client_proc(void *arg) {
    5. 	struct async_context *ctx = (struct async_context*)arg;
    6.  
    7. 	int epfd = ctx->epfd;
    8.  
    9. 	while (1) {
    10.  
    11. 		struct epoll_event events[ASYNC_CLIENT_NUM] = {0};
    12.  
    13. 		int nready = epoll_wait(epfd, events, ASYNC_CLIENT_NUM, -1);
    14. 		if (nready < 0) {
    15. 			if (errno == EINTR || errno == EAGAIN) { //非阻塞
    16. 				continue;
    17. 			} else {
    18. 				break;
    19. 			}
    20. 		} else if (nready == 0) {
    21. 			continue;
    22. 		}
    23.  
    24. 		printf("nready:%d\n", nready);
    25. 		int i = 0;
    26. 		for (i = 0;i < nready;i ++) {
    27.  
    28. 			struct ep_arg *data = (struct ep_arg*)events[i].data.ptr;
    29. 			int sockfd = data->sockfd;
    30.  
    31. 			char buffer[1024] = {0};
    32. 			struct sockaddr_in addr;
    33. 			size_t addr_len = sizeof(struct sockaddr_in);
    34. 			int n = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr, (socklen_t*)&addr_len);
    35.  
    36. 			struct dns_item *domain_list = NULL;
    37. 			int count = dns_parse_response(buffer, &domain_list);
    38.  
    39. 			data->cb(domain_list, count); //call cb
    40. 			
    41. 			int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
    42. 			//printf("epoll_ctl DEL --> sockfd:%d\n", sockfd);
    43.  
    44. 			close(sockfd); /
    45.  
    46. 			dns_async_client_free_domains(domain_list, count);
    47. 			free(data);
    48.  
    49. 		}
    50. 		
    51. 	}
    52. 	
    53. }

    4. Destroy_ctx()

    销毁线程和关闭epfd.

    1. int dns_async_client_destroy(struct async_context *ctx) {
    2. 	if (ctx == NULL) return -EINVAL;
    3. 	
    4. 	pthread_cancel(ctx->thid);
    5. 	close(ctx->epfd);
    6. 	return 0;
    7.  
    8. }

     完整代码

    1. //gcc -o client async_dns_client_noblock.c -lpthread
    2. #include <stdio.h>
    3. #include <stdlib.h>
    4. #include <string.h>
    5. #include <unistd.h>
    6.  
    7. #include <errno.h>
    8. #include <fcntl.h>
    9.  
    10. #include <sys/types.h>
    11. #include <sys/socket.h>
    12. #include <netinet/in.h>
    13.  
    14. #include <sys/epoll.h>
    15. #include <netdb.h>
    16. #include <arpa/inet.h>
    17.  
    18. #include <pthread.h>
    19.  
    20.  
    21. #define DNS_SVR				"192.168.1.1"
    22.  
    23. #define DNS_HOST			0x01
    24. #define DNS_CNAME			0x05
    25.  
    26. #define ASYNC_CLIENT_NUM		1024
    27.  
    28. //DNS 头部
    29. struct dns_header {
    30. 	unsigned short id;
    31. 	unsigned short flags;
    32. 	unsigned short qdcount;
    33. 	unsigned short ancount;
    34. 	unsigned short nscount;
    35. 	unsigned short arcount;
    36. };
    37.  
    38. //DNS请求
    39. struct dns_question {
    40. 	int length;
    41. 	unsigned short qtype;
    42. 	unsigned short qclass;
    43. 	char *qname;
    44. };
    45.  
    46. struct dns_item {
    47. 	char *domain;
    48. 	char *ip;
    49. };
    50.  
    51. typedef void (*async_result_cb)(struct dns_item *list, int count);
    52.  
    53. //epoll结构体
    54. struct async_context {
    55. 	int epfd;
    56. };
    57.  
    58. //epoll参数
    59. struct ep_arg {
    60. 	int sockfd;
    61. 	async_result_cb cb;
    62. };
    63.  
    64. //填充 header
    65. int dns_create_header(struct dns_header *header) {
    66.  
    67. 	if (header == NULL) return -1;
    68. 	memset(header, 0, sizeof(struct dns_header));
    69.  
    70. 	srandom(time(NULL));
    71.  
    72. 	header->id = random();
    73. 	header->flags |= htons(0x0100);
    74. 	header->qdcount = htons(1);
    75.  
    76. 	return 0;
    77. }
    78.  
    79. //填充 question
    80. int dns_create_question(struct dns_question *question, const char *hostname) {
    81.  
    82. 	if (question == NULL) return -1;
    83. 	memset(question, 0, sizeof(struct dns_question));
    84.  
    85. 	question->qname = (char*)malloc(strlen(hostname) + 2);
    86. 	if (question->qname == NULL) return -2;
    87.  
    88. 	question->length = strlen(hostname) + 2;
    89.  
    90. 	question->qtype = htons(1);
    91. 	question->qclass = htons(1);
    92.  
    93. 	const char delim[2] = ".";
    94.  
    95. 	char *hostname_dup = strdup(hostname);
    96. 	char *token = strtok(hostname_dup, delim);
    97.  
    98. 	char *qname_p = question->qname;
    99.  
    100. 	while (token != NULL) {
    101.  
    102. 		size_t len = strlen(token);
    103.  
    104. 		*qname_p = len;
    105. 		qname_p ++;
    106.  
    107. 		strncpy(qname_p, token, len+1);
    108. 		qname_p += len;
    109.  
    110. 		token = strtok(NULL, delim);
    111. 	}
    112.  
    113. 	free(hostname_dup);
    114.  
    115. 	return 0;
    116. 	
    117. }
    118.  
    119. //准备请求头
    120. int dns_build_request(struct dns_header *header, struct dns_question *question, char *request) {
    121.  
    122. 	int header_s = sizeof(struct dns_header);
    123. 	int question_s = question->length + sizeof(question->qtype) + sizeof(question->qclass);
    124.  
    125. 	int length = question_s + header_s;
    126.  
    127. 	int offset = 0;
    128. 	memcpy(request+offset, header, sizeof(struct dns_header));
    129. 	offset += sizeof(struct dns_header);
    130.  
    131. 	memcpy(request+offset, question->qname, question->length);
    132. 	offset += question->length;
    133.  
    134. 	memcpy(request+offset, &question->qtype, sizeof(question->qtype));
    135. 	offset += sizeof(question->qtype);
    136.  
    137. 	memcpy(request+offset, &question->qclass, sizeof(question->qclass));
    138.  
    139. 	return length;
    140. 	
    141. }
    142.  
    143. static int is_pointer(int in) {
    144. 	return ((in & 0xC0) == 0xC0);
    145. }
    146.  
    147. static int set_block(int fd, int block) {
    148. 	int flags = fcntl(fd, F_GETFL, 0);
    149. 	if (flags < 0) return flags;
    150.  
    151. 	if (block) {        
    152. 		flags &= ~O_NONBLOCK;    
    153. 	} else {        
    154. 		flags |= O_NONBLOCK;    
    155. 	}
    156.  
    157. 	if (fcntl(fd, F_SETFL, flags) < 0) return -1;
    158.  
    159. 	return 0;
    160. }
    161.  
    162. static void dns_parse_name(unsigned char *chunk, unsigned char *ptr, char *out, int *len) {
    163.  
    164. 	int flag = 0, n = 0, alen = 0;
    165. 	char *pos = out + (*len);
    166.  
    167. 	while (1) {
    168.  
    169. 		flag = (int)ptr[0];
    170. 		if (flag == 0) break;
    171.  
    172. 		if (is_pointer(flag)) {
    173. 			
    174. 			n = (int)ptr[1];
    175. 			ptr = chunk + n;
    176. 			dns_parse_name(chunk, ptr, out, len);
    177. 			break;
    178. 			
    179. 		} else {
    180.  
    181. 			ptr ++;
    182. 			memcpy(pos, ptr, flag);
    183. 			pos += flag;
    184. 			ptr += flag;
    185.  
    186. 			*len += flag;
    187. 			if ((int)ptr[0] != 0) {
    188. 				memcpy(pos, ".", 1);
    189. 				pos += 1;
    190. 				(*len) += 1;
    191. 			}
    192. 		}
    193. 	
    194. 	}
    195. 	
    196. }
    197.  
    198.  
    199. //解析 response
    200. static int dns_parse_response(char *buffer, struct dns_item **domains) {
    201.  
    202. 	int i = 0;
    203. 	unsigned char *ptr = buffer;
    204.  
    205. 	ptr += 4;
    206. 	int querys = ntohs(*(unsigned short*)ptr);
    207.  
    208. 	ptr += 2;
    209. 	int answers = ntohs(*(unsigned short*)ptr);
    210.  
    211. 	ptr += 6;
    212. 	for (i = 0;i < querys;i ++) {
    213. 		while (1) {
    214. 			int flag = (int)ptr[0];
    215. 			ptr += (flag + 1);
    216.  
    217. 			if (flag == 0) break;
    218. 		}
    219. 		ptr += 4;
    220. 	}
    221.  
    222. 	char cname[128], aname[128], ip[20], netip[4];
    223. 	int len, type, ttl, datalen;
    224.  
    225. 	int cnt = 0;
    226. 	struct dns_item *list = (struct dns_item*)calloc(answers, sizeof(struct dns_item));
    227. 	if (list == NULL) {
    228. 		return -1;
    229. 	}
    230.  
    231. 	for (i = 0;i < answers;i ++) {
    232. 		
    233. 		bzero(aname, sizeof(aname));
    234. 		len = 0;
    235.  
    236. 		dns_parse_name(buffer, ptr, aname, &len);
    237. 		ptr += 2;
    238.  
    239. 		type = htons(*(unsigned short*)ptr);
    240. 		ptr += 4;
    241.  
    242. 		ttl = htons(*(unsigned short*)ptr);
    243. 		ptr += 4;
    244.  
    245. 		datalen = ntohs(*(unsigned short*)ptr);
    246. 		ptr += 2;
    247.  
    248. 		if (type == DNS_CNAME) {
    249.  
    250. 			bzero(cname, sizeof(cname));
    251. 			len = 0;
    252. 			dns_parse_name(buffer, ptr, cname, &len);
    253. 			ptr += datalen;
    254. 			
    255. 		} else if (type == DNS_HOST) {
    256.  
    257. 			bzero(ip, sizeof(ip));
    258.  
    259. 			if (datalen == 4) {
    260. 				memcpy(netip, ptr, datalen);
    261. 				inet_ntop(AF_INET , netip , ip , sizeof(struct sockaddr));
    262.  
    263. 				//printf("%s has address %s\n" , aname, ip);
    264. 				//printf("\tTime to live: %d minutes , %d seconds\n", ttl / 60, ttl % 60);
    265.  
    266. 				list[cnt].domain = (char *)calloc(strlen(aname) + 1, 1);
    267. 				memcpy(list[cnt].domain, aname, strlen(aname));
    268. 				
    269. 				list[cnt].ip = (char *)calloc(strlen(ip) + 1, 1);
    270. 				memcpy(list[cnt].ip, ip, strlen(ip));
    271. 				
    272. 				cnt ++;
    273. 			}
    274. 			
    275. 			ptr += datalen;
    276. 		}
    277. 	}
    278.  
    279. 	*domains = list;
    280. 	ptr += 2;
    281.  
    282. 	return cnt;
    283. 	
    284. }
    285.  
    286. //域名请求
    287. int dns_client_commit(const char *domain) {
    288.  
    289. 	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    290. 	if (sockfd < 0) {
    291. 		perror("create socket failed\n");
    292. 		exit(-1);
    293. 	}
    294.  
    295. 	printf("url:%s\n", domain);
    296.  
    297. 	set_block(sockfd, 0); //nonblock
    298.  
    299. 	struct sockaddr_in dest;
    300. 	bzero(&dest, sizeof(dest));
    301. 	dest.sin_family = AF_INET;
    302. 	dest.sin_port = htons(53);
    303. 	dest.sin_addr.s_addr = inet_addr(DNS_SVR);
    304. 	
    305. 	int ret = connect(sockfd, (struct sockaddr*)&dest, sizeof(dest));
    306. 	//printf("connect :%d\n", ret);
    307.  
    308. 	struct dns_header header = {0};
    309. 	dns_create_header(&header);
    310.  
    311. 	struct dns_question question = {0};
    312. 	dns_create_question(&question, domain);
    313.  
    314. 	char request[1024] = {0};
    315. 	int req_len = dns_build_request(&header, &question, request);
    316. 	int slen = sendto(sockfd, request, req_len, 0, (struct sockaddr*)&dest, sizeof(struct sockaddr));
    317.  
    318. 	while (1) {
    319. 		char buffer[1024] = {0};
    320. 		struct sockaddr_in addr;
    321. 		size_t addr_len = sizeof(struct sockaddr_in);
    322. 	
    323. 		int n = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr, (socklen_t*)&addr_len);
    324. 		if (n <= 0) continue;
    325. 		
    326. 		printf("recvfrom n : %d\n", n);
    327. 		struct dns_item *domains = NULL;
    328. 		dns_parse_response(buffer, &domains);
    329.  
    330. 		break;
    331. 	}
    332.  
    333. 	return 0;
    334. }
    335.  
    336. //销毁
    337. void dns_async_client_free_domains(struct dns_item *list, int count) {
    338. 	int i = 0;
    339.  
    340. 	for (i = 0;i < count;i ++) {
    341. 		free(list[i].domain);
    342. 		free(list[i].ip);
    343. 	}
    344.  
    345. 	free(list);
    346. }
    347.  
    348.  
    349. //dns_async_client_proc()
    350. //epoll_wait
    351. //result callback
    352. static void* dns_async_client_proc(void *arg) {
    353. 	struct async_context *ctx = (struct async_context*)arg;
    354.  
    355. 	int epfd = ctx->epfd;
    356.  
    357. 	while (1) {
    358.  
    359. 		struct epoll_event events[ASYNC_CLIENT_NUM] = {0};
    360.  
    361. 		int nready = epoll_wait(epfd, events, ASYNC_CLIENT_NUM, -1);
    362. 		if (nready < 0) {
    363. 			if (errno == EINTR || errno == EAGAIN) { //非阻塞
    364. 				continue;
    365. 			} else {
    366. 				break;
    367. 			}
    368. 		} else if (nready == 0) {
    369. 			continue;
    370. 		}
    371.  
    372. 		printf("nready:%d\n", nready);
    373. 		int i = 0;
    374. 		for (i = 0;i < nready;i ++) {
    375.  
    376. 			struct ep_arg *data = (struct ep_arg*)events[i].data.ptr;
    377. 			int sockfd = data->sockfd;
    378.  
    379. 			char buffer[1024] = {0};
    380. 			struct sockaddr_in addr;
    381. 			size_t addr_len = sizeof(struct sockaddr_in);
    382. 			int n = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr, (socklen_t*)&addr_len);
    383.  
    384. 			struct dns_item *domain_list = NULL;
    385. 			int count = dns_parse_response(buffer, &domain_list);
    386.  
    387. 			data->cb(domain_list, count); //call cb
    388. 			
    389. 			int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
    390. 			//printf("epoll_ctl DEL --> sockfd:%d\n", sockfd);
    391.  
    392. 			close(sockfd); /
    393.  
    394. 			dns_async_client_free_domains(domain_list, count);
    395. 			free(data);
    396.  
    397. 		}
    398. 		
    399. 	}
    400. 	
    401. }
    402.  
    403.  
    404.  
    405. //dns_async_client_init()
    406. //epoll init
    407. //thread init
    408. struct async_context *dns_async_client_init(void) {
    409.  
    410. 	int epfd = epoll_create(1); // 
    411. 	if (epfd < 0) return NULL;
    412.  
    413. 	struct async_context *ctx = calloc(1, sizeof(struct async_context));
    414. 	if (ctx == NULL) {
    415. 		close(epfd);
    416. 		return NULL;
    417. 	}
    418. 	ctx->epfd = epfd;
    419.  
    420. 	pthread_t thread_id;
    421. 	int ret = pthread_create(&thread_id, NULL, dns_async_client_proc, ctx);
    422. 	if (ret) {
    423. 		perror("pthread_create");
    424. 		return NULL;
    425. 	}
    426. 	usleep(1); //child go first
    427.  
    428. 	return ctx;
    429. }
    430.  
    431.  
    432. //dns_async_client_commit(ctx, domain)
    433. //socket init
    434. //dns_request
    435. //sendto dns send
    436. int dns_async_client_commit(struct async_context* ctx, const char *domain, async_result_cb cb) {
    437.  
    438. 	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    439. 	if (sockfd < 0) {
    440. 		perror("create socket failed\n");
    441. 		exit(-1);
    442. 	}
    443.  
    444. 	printf("url:%s\n", domain);
    445.  
    446. 	//设置为非阻塞
    447. 	set_block(sockfd, 0); //nonblock
    448.  
    449. 	struct sockaddr_in dest;
    450. 	bzero(&dest, sizeof(dest));
    451. 	dest.sin_family = AF_INET;
    452. 	dest.sin_port = htons(53);
    453. 	dest.sin_addr.s_addr = inet_addr(DNS_SVR);
    454. 	
    455. 	int ret = connect(sockfd, (struct sockaddr*)&dest, sizeof(dest));
    456. 	//printf("connect :%d\n", ret);
    457.  
    458. 	struct dns_header header = {0};
    459. 	dns_create_header(&header); //填充 header
    460.  
    461. 	struct dns_question question = {0};
    462. 	dns_create_question(&question, domain); //填充 question
    463.  
    464. 	char request[1024] = {0};
    465. 	int req_len = dns_build_request(&header, &question, request); //准备请求头
    466. 	int slen = sendto(sockfd, request, req_len, 0, (struct sockaddr*)&dest, sizeof(struct sockaddr));
    467.  
    468. 	struct ep_arg *eparg = (struct ep_arg*)calloc(1, sizeof(struct ep_arg));
    469. 	if (eparg == NULL) return -1;
    470. 	eparg->sockfd = sockfd;
    471. 	eparg->cb = cb;
    472.  
    473. 	//加入epoll
    474. 	struct epoll_event ev;
    475. 	ev.data.ptr = eparg;
    476. 	ev.events = EPOLLIN;
    477. 	ret = epoll_ctl(ctx->epfd, EPOLL_CTL_ADD, sockfd, &ev); 
    478. 	//printf(" epoll_ctl ADD: sockfd->%d, ret:%d\n", sockfd, ret);
    479. 	return ret;
    480. }
    481.  
    482. //回调函数
    483. static void dns_async_client_result_callback(struct dns_item *list, int count) {
    484. 	int i = 0;
    485.  
    486. 	for (i = 0;i < count;i ++) {
    487. 		printf("name:%s, ip:%s\n", list[i].domain, list[i].ip);
    488. 	}
    489. }
    490.  
    491. char *domain[] = {
    492. 	"www.ntytcp.com",
    493. 	"bojing.wang",
    494. 	"www.baidu.com",
    495. 	"tieba.baidu.com",
    496. 	"news.baidu.com",
    497. 	"zhidao.baidu.com",
    498. 	"music.baidu.com",
    499. 	"image.baidu.com",
    500. 	"v.baidu.com",
    501. 	"map.baidu.com",
    502. 	"baijiahao.baidu.com",
    503. 	"xueshu.baidu.com",
    504. 	"cloud.baidu.com",
    505. 	"www.163.com",
    506. 	"open.163.com",
    507. 	"auto.163.com",
    508. 	"gov.163.com",
    509. 	"money.163.com",
    510. 	"sports.163.com",
    511. 	"tech.163.com",
    512. 	"edu.163.com",
    513. 	"www.taobao.com",
    514. 	"q.taobao.com",
    515. 	"sf.taobao.com",
    516. 	"yun.taobao.com",
    517. 	"baoxian.taobao.com",
    518. 	"www.tmall.com",
    519. 	"suning.tmall.com",
    520. 	"www.tencent.com",
    521. 	"www.qq.com",
    522. 	"www.aliyun.com",
    523. 	"www.ctrip.com",
    524. 	"hotels.ctrip.com",
    525. 	"hotels.ctrip.com",
    526. 	"vacations.ctrip.com",
    527. 	"flights.ctrip.com",
    528. 	"trains.ctrip.com",
    529. 	"bus.ctrip.com",
    530. 	"car.ctrip.com",
    531. 	"piao.ctrip.com",
    532. 	"tuan.ctrip.com",
    533. 	"you.ctrip.com",
    534. 	"g.ctrip.com",
    535. 	"lipin.ctrip.com",
    536. 	"ct.ctrip.com"
    537. };
    538.  
    539. int main(int argc, char *argv[]) {
    540. #if 0
    541. 	dns_client_commit(argv[1]);
    542. #else
    543.  
    544. 	struct async_context *ctx = dns_async_client_init();
    545. 	if (ctx == NULL) return -2;
    546.  
    547. 	int count = sizeof(domain) / sizeof(domain[0]);
    548. 	int i = 0;
    549.  
    550. 	for (i = 0;i < count;i ++) {
    551. 		dns_async_client_commit(ctx, domain[i], dns_async_client_result_callback);
    552. 		//sleep(2);
    553. 	}
    554.  
    555. 	getchar();
    556. #endif
    557. 	
    558. }
    559.  
    560.  
    561.  
    562.  
    563.  
    564.  
    565.

    运行效果

    3. 总结

    同步的方案

    Recvfrom()

    异步的方案

    Epoll_ctl();

    异步的优点：异步比同步性能更好

    异步的缺点：异步不好理解，流程不清晰

    什么是协程？

    1.有异步的性能

    2.同步的编程方式

            协程，是一种比线程更加轻量级的存在，协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行）。这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。

  • 相关阅读:
    微突发丢包的艺术
    Android源码下载
    【Vue3】使用v-model实现父子组件通信（常用在组件封装规范中）
    C++DAY48
    C语言文件操作
    前端食堂技术周刊第 100 期：TS 5.3 Beta、ViteConf2023、Rspress 1.0、Fresh 1.5、Chrome 118
    如何在 pyqt 中自定义工具提示 ToolTip
    yolov6训练记录
    最优化方法——QR分解
    六轴传感器 SH3001
  • 原文地址：https://blog.csdn.net/kakaka666/article/details/126438490