同步与异步的概念和区别？
举个例子：客户端要向服务器发送10个请求，并且需要等待服务器响应后，再根据响应的结果做业务处理。
同步：可以简单理解成串行，客户端发送请求后等待服务器响应完，根据响应的结果做完业务逻辑，再发送下一个请求。
异步：可以简单理解成并行，客户端不需要等待服务器响应，一直发送请求，每次发送完一个请求后，把对应的sockfd、数据处理回调函数、参数，添加到epfd（epoll的套接字）中，由另一个线程对epfd检测是否可读、接收和调用回调函数处理。
同步异步时序分析：
同步异步优缺点分析：
| 同步 | 异步 |
| 效率低 | 效率高 |
| 阻塞等待（受服务器和或网络影响，易卡住） | 多路复用（不受服务器或网络影响，不会卡） |
| 逻辑简单 | 逻辑比同步复杂一点点，但还是比较简单、思路清晰 |
异步请求池的框架如何搭建，接口如何设计？
King式四元组：
init() -- 初始化
commit() -- 请求后添加到epoll
callback() -- 数据处理回调
destroy() -- 销毁
先用伪代码整理思路，后面呈上完整代码：
1.init
epoll_create(1);
pthread_create();
2.commit
a.socket -- 创建socket套接字，用于跟服务器通信
b.connect server -- 连接服务器
c.encode -- redis/mysql/dns 封装协议内容
d.send -- 发送请求
e.epoll_ctl -- sockfd添加到epoll
3.callback
while (1) {
epoll_wait();
recv();
parse();
fd-->epoll delete
}
4.destroy
close(epfd);
pthread_cancel(thid);
话不多说，下面以请求dns服务器为例，完整代码：
同步代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <pthread.h>
#define DNS_SVR "114.114.114.114"
#define DNS_HOST 0x01
#define DNS_CNAME 0x05
struct dns_header {
unsigned short id;
unsigned short flags;
unsigned short qdcount;
unsigned short ancount;
unsigned short nscount;
unsigned short arcount;
};
struct dns_question {
int length;
unsigned short qtype;
unsigned short qclass;
char *qname;
};
struct dns_item {
char *domain;
char *ip;
};
int dns_create_header(struct dns_header *header) {
if (header == NULL) return -1;
memset(header, 0, sizeof(struct dns_header));
srandom(time(NULL));
header->id = random();
header->flags |= htons(0x0100);
header->qdcount = htons(1);
return 0;
}
int dns_create_question(struct dns_question *question, const char *hostname) {
if (question == NULL) return -1;
memset(question, 0, sizeof(struct dns_question));
question->qname = (char*)malloc(strlen(hostname) + 2);
if (question->qname == NULL) return -2;
question->length = strlen(hostname) + 2;
question->qtype = htons(1);
question->qclass = htons(1);
const char delim[2] = ".";
char *hostname_dup = strdup(hostname);
char *token = strtok(hostname_dup, delim);
char *qname_p = question->qname;
while (token != NULL) {
size_t len = strlen(token);
*qname_p = len;
qname_p ++;
strncpy(qname_p, token, len+1);
qname_p += len;
token = strtok(NULL, delim);
}
free(hostname_dup);
return 0;
}
int dns_build_request(struct dns_header *header, struct dns_question *question, char *request) {
int header_s = sizeof(struct dns_header);
int question_s = question->length + sizeof(question->qtype) + sizeof(question->qclass);
int length = question_s + header_s;
int offset = 0;
memcpy(request+offset, header, sizeof(struct dns_header));
offset += sizeof(struct dns_header);
memcpy(request+offset, question->qname, question->length);
offset += question->length;
memcpy(request+offset, &question->qtype, sizeof(question->qtype));
offset += sizeof(question->qtype);
memcpy(request+offset, &question->qclass, sizeof(question->qclass));
return length;
}
static int is_pointer(int in) {
return ((in & 0xC0) == 0xC0);
}
static void dns_parse_name(unsigned char *chunk, unsigned char *ptr, char *out, int *len) {
int flag = 0, n = 0, alen = 0;
char *pos = out + (*len);
while (1) {
flag = (int)ptr[0];
if (flag == 0) break;
if (is_pointer(flag)) {
n = (int)ptr[1];
ptr = chunk + n;
dns_parse_name(chunk, ptr, out, len);
break;
} else {
ptr ++;
memcpy(pos, ptr, flag);
pos += flag;
ptr += flag;
*len += flag;
if ((int)ptr[0] != 0) {
memcpy(pos, ".", 1);
pos += 1;
(*len) += 1;
}
}
}
}
static int dns_parse_response(char *buffer, struct dns_item **domains) {
int i = 0;
unsigned char *ptr = buffer;
ptr += 4;
int querys = ntohs(*(unsigned short*)ptr);
ptr += 2;
int answers = ntohs(*(unsigned short*)ptr);
ptr += 6;
for (i = 0;i < querys;i ++) {
while (1) {
int flag = (int)ptr[0];
ptr += (flag + 1);
if (flag == 0) break;
}
ptr += 4;
}
char cname[128], aname[128], ip[20], netip[4];
int len, type, ttl, datalen;
int cnt = 0;
struct dns_item *list = (struct dns_item*)calloc(answers, sizeof(struct dns_item));
if (list == NULL) {
return -1;
}
for (i = 0;i < answers;i ++) {
bzero(aname, sizeof(aname));
len = 0;
dns_parse_name(buffer, ptr, aname, &len);
ptr += 2;
type = htons(*(unsigned short*)ptr);
ptr += 4;
ttl = htons(*(unsigned short*)ptr);
ptr += 4;
datalen = ntohs(*(unsigned short*)ptr);
ptr += 2;
if (type == DNS_CNAME) {
bzero(cname, sizeof(cname));
len = 0;
dns_parse_name(buffer, ptr, cname, &len);
ptr += datalen;
} else if (type == DNS_HOST) {
bzero(ip, sizeof(ip));
if (datalen == 4) {
memcpy(netip, ptr, datalen);
inet_ntop(AF_INET , netip , ip , sizeof(struct sockaddr));
printf("%s has address %s\n" , aname, ip);
printf("\tTime to live: %d minutes , %d seconds\n", ttl / 60, ttl % 60);
list[cnt].domain = (char *)calloc(strlen(aname) + 1, 1);
memcpy(list[cnt].domain, aname, strlen(aname));
list[cnt].ip = (char *)calloc(strlen(ip) + 1, 1);
memcpy(list[cnt].ip, ip, strlen(ip));
cnt ++;
}
ptr += datalen;
}
}
*domains = list;
ptr += 2;
return cnt;
}
int dns_client_commit(const char *domain) {
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("create socket failed\n");
exit(-1);
}
printf("url:%s\n", domain);
// default block
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));
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);
printf("recvfrom n : %d\n", n);
struct dns_item *domains = NULL;
dns_parse_response(buffer, &domains);
return 0;
}
char *domain[] = {
"www.ntytcp.com",
"bojing.wang",
"www.baidu.com",
"tieba.baidu.com",
"news.baidu.com",
"zhidao.baidu.com",
"music.baidu.com",
"image.baidu.com",
"v.baidu.com",
"map.baidu.com",
"baijiahao.baidu.com",
"xueshu.baidu.com",
"cloud.baidu.com",
"www.163.com",
"open.163.com",
"auto.163.com",
"gov.163.com",
"money.163.com",
"sports.163.com",
"tech.163.com",
"edu.163.com",
"www.taobao.com",
"q.taobao.com",
"sf.taobao.com",
"yun.taobao.com",
"baoxian.taobao.com",
"www.tmall.com",
"suning.tmall.com",
"www.tencent.com",
"www.qq.com"
};
int main(int argc, char *argv[]) {
int count = sizeof(domain) / sizeof(domain[0]);
for (int i = 0;i < count;i ++) {
dns_client_commit(domain[i]);
}
getchar();
return 0;
}
编译：gcc -o sync_dns_client sync_dns_client.c
执行：./sync_dns_client
结果：
注意：同步请求dns服务器时，因为阻塞等待，有时服务器无法及时响应会出现程序卡住问题，所以阻塞不安全。
异步代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <pthread.h>
#define DNS_SVR "114.114.114.114"
#define DNS_HOST 0x01
#define DNS_CNAME 0x05
struct dns_header {
unsigned short id;
unsigned short flags;
unsigned short qdcount;
unsigned short ancount;
unsigned short nscount;
unsigned short arcount;
};
struct dns_question {
int length;
unsigned short qtype;
unsigned short qclass;
char *qname;
};
struct dns_item {
char *domain;
char *ip;
};
int dns_create_header(struct dns_header *header) {
if (header == NULL) return -1;
memset(header, 0, sizeof(struct dns_header));
srandom(time(NULL));
header->id = random();
header->flags |= htons(0x0100);
header->qdcount = htons(1);
return 0;
}
int dns_create_question(struct dns_question *question, const char *hostname) {
if (question == NULL) return -1;
memset(question, 0, sizeof(struct dns_question));
question->qname = (char*)malloc(strlen(hostname) + 2);
if (question->qname == NULL) return -2;
question->length = strlen(hostname) + 2;
question->qtype = htons(1);
question->qclass = htons(1);
const char delim[2] = ".";
char *hostname_dup = strdup(hostname);
char *token = strtok(hostname_dup, delim);
char *qname_p = question->qname;
while (token != NULL) {
size_t len = strlen(token);
*qname_p = len;
qname_p ++;
strncpy(qname_p, token, len+1);
qname_p += len;
token = strtok(NULL, delim);
}
free(hostname_dup);
return 0;
}
int dns_build_request(struct dns_header *header, struct dns_question *question, char *request) {
int header_s = sizeof(struct dns_header);
int question_s = question->length + sizeof(question->qtype) + sizeof(question->qclass);
int length = question_s + header_s;
int offset = 0;
memcpy(request+offset, header, sizeof(struct dns_header));
offset += sizeof(struct dns_header);
memcpy(request+offset, question->qname, question->length);
offset += question->length;
memcpy(request+offset, &question->qtype, sizeof(question->qtype));
offset += sizeof(question->qtype);
memcpy(request+offset, &question->qclass, sizeof(question->qclass));
return length;
}
static int is_pointer(int in) {
return ((in & 0xC0) == 0xC0);
}
static void dns_parse_name(unsigned char *chunk, unsigned char *ptr, char *out, int *len) {
int flag = 0, n = 0, alen = 0;
char *pos = out + (*len);
while (1) {
flag = (int)ptr[0];
if (flag == 0) break;
if (is_pointer(flag)) {
n = (int)ptr[1];
ptr = chunk + n;
dns_parse_name(chunk, ptr, out, len);
break;
} else {
ptr ++;
memcpy(pos, ptr, flag);
pos += flag;
ptr += flag;
*len += flag;
if ((int)ptr[0] != 0) {
memcpy(pos, ".", 1);
pos += 1;
(*len) += 1;
}
}
}
}
static int dns_parse_response(char *buffer, struct dns_item **domains) {
int i = 0;
unsigned char *ptr = buffer;
ptr += 4;
int querys = ntohs(*(unsigned short*)ptr);
ptr += 2;
int answers = ntohs(*(unsigned short*)ptr);
ptr += 6;
for (i = 0;i < querys;i ++) {
while (1) {
int flag = (int)ptr[0];
ptr += (flag + 1);
if (flag == 0) break;
}
ptr += 4;
}
char cname[128], aname[128], ip[20], netip[4];
int len, type, ttl, datalen;
int cnt = 0;
struct dns_item *list = (struct dns_item*)calloc(answers, sizeof(struct dns_item));
if (list == NULL) {
return -1;
}
for (i = 0;i < answers;i ++) {
bzero(aname, sizeof(aname));
len = 0;
dns_parse_name(buffer, ptr, aname, &len);
ptr += 2;
type = htons(*(unsigned short*)ptr);
ptr += 4;
ttl = htons(*(unsigned short*)ptr);
ptr += 4;
datalen = ntohs(*(unsigned short*)ptr);
ptr += 2;
if (type == DNS_CNAME) {
bzero(cname, sizeof(cname));
len = 0;
dns_parse_name(buffer, ptr, cname, &len);
ptr += datalen;
} else if (type == DNS_HOST) {
bzero(ip, sizeof(ip));
if (datalen == 4) {
memcpy(netip, ptr, datalen);
inet_ntop(AF_INET , netip , ip , sizeof(struct sockaddr));
printf("%s has address %s\n" , aname, ip);
printf("\tTime to live: %d minutes , %d seconds\n", ttl / 60, ttl % 60);
list[cnt].domain = (char *)calloc(strlen(aname) + 1, 1);
memcpy(list[cnt].domain, aname, strlen(aname));
list[cnt].ip = (char *)calloc(strlen(ip) + 1, 1);
memcpy(list[cnt].ip, ip, strlen(ip));
cnt ++;
}
ptr += datalen;
}
}
*domains = list;
ptr += 2;
return cnt;
}
int dns_client_commit(const char *domain) {
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("create socket failed\n");
exit(-1);
}
printf("url:%s\n", domain);
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));
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);
printf("recvfrom n : %d\n", n);
struct dns_item *domains = NULL;
dns_parse_response(buffer, &domains);
return 0;
}
char *domain[] = {
"www.ntytcp.com",
"bojing.wang",
"www.baidu.com",
"tieba.baidu.com",
"news.baidu.com",
"zhidao.baidu.com",
"music.baidu.com",
"image.baidu.com",
"v.baidu.com",
"map.baidu.com",
"baijiahao.baidu.com",
"xueshu.baidu.com",
"cloud.baidu.com",
"www.163.com",
"open.163.com",
"auto.163.com",
"gov.163.com",
"money.163.com",
"sports.163.com",
"tech.163.com",
"edu.163.com",
"www.taobao.com",
"q.taobao.com",
"sf.taobao.com",
"yun.taobao.com",
"baoxian.taobao.com",
"www.tmall.com",
"suning.tmall.com",
"www.tencent.com",
"www.qq.com"
};
struct async_context {
int epfd;
pthread_t thid;
};
typedef void (*async_result_cb)(struct dns_item *list, int count);
struct epoll_arg {
async_result_cb cb;
int fd;
};
#define ASYNC_CLIENT_NUM 1024
void dns_async_free_domain(struct dns_item *domains, int count) {
int i = 0;
for (i = 0;i < count;i ++) {
free(domains[i].domain);
free(domains[i].ip);
}
free(domains);
}
void *dns_async_callback(void *arg) {
struct async_context *ctx = (struct async_context *)arg;
while (1) {
struct epoll_event events[ASYNC_CLIENT_NUM] = {0};
int nready = epoll_wait(ctx->epfd, events, ASYNC_CLIENT_NUM, -1);
if (nready < 0) continue;
int i = 0;
for (i = 0;i < nready;i ++) {
struct epoll_arg *data = events[i].data.ptr;
int sockfd = data->fd;
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);
printf("recvfrom n : %d\n", n);
struct dns_item *domains = NULL;
int count = dns_parse_response(buffer, &domains);
data->cb(domains, count);
epoll_ctl(ctx->epfd, EPOLL_CTL_DEL, sockfd, NULL);
close(sockfd);
dns_async_free_domain(domains, count);
free(data);
}
}
return NULL;
}
int dns_async_context_init(struct async_context *ctx) {
if (ctx == NULL) return -1;
// epoll_create
int epfd = epoll_create(1);
if (epfd < 0) return -1;
ctx->epfd = epfd;
// pthread_create
int ret = pthread_create(&ctx->thid, NULL, dns_async_callback, ctx);
if (ret) {
close(epfd);
return -1;
}
return 0;
}
int dns_async_context_destroy(struct async_context *ctx) {
if (ctx == NULL) return -1;
// close(epfd)
close(ctx->epfd);
// pthread_cancel(thid)
pthread_cancel(ctx->thid);
return 0;
}
int dns_async_client_commit(struct async_context *ctx, async_result_cb cb,const char *domain) {
//1 socket
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("create socket failed\n");
exit(-1);
}
printf("url:%s\n", domain);
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);
//1 connect server
int ret = connect(sockfd, (struct sockaddr*)&dest, sizeof(dest));
printf("connect :%d\n", ret);
//1 encode protocol
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);
//1 send
int slen = sendto(sockfd, request, req_len, 0, (struct sockaddr*)&dest, sizeof(struct sockaddr));
#if 0
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);
printf("recvfrom n : %d\n", n);
struct dns_item *domains = NULL;
dns_parse_response(buffer, &domains);
#else
struct epoll_arg *eparg = (struct epoll_arg *)calloc(1, sizeof(struct epoll_arg));
if (eparg == NULL) return -1;
eparg->fd = sockfd;
eparg->cb = cb;
struct epoll_event ev;
ev.data.ptr = eparg;
ev.events = EPOLLIN;
epoll_ctl(ctx->epfd, EPOLL_CTL_ADD, sockfd, &ev);
#endif
return 0;
}
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);
}
}
int main(int argc, char *argv[]) {
struct async_context *ctx = calloc(1, sizeof(struct async_context));
dns_async_context_init(ctx);
int count = sizeof(domain) / sizeof(domain[0]);
for (int i = 0;i < count;i ++) {
dns_async_client_commit(ctx, dns_async_client_result_callback, domain[i]);
}
dns_async_context_destroy(ctx);
free(ctx);
getchar();
return 0;
}
编译：gcc -o async_dns_client async_dns_client.c -lpthread
执行：./async_dns_client
结果：
对比同步和异步的执行过程，异步肉眼可见的效率提升。
文章仅作个人学习总结，觉得有用并喜欢文章风格的朋友可以添加关注，后期还有更多知识点文章更新，谢谢~
扫一扫
602
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
