异步请求池的框架（以DNS请求为例）

最新推荐文章于 2024-06-24 11:27:10 发布
最新推荐文章于 2024-06-24 11:27:10 发布
阅读量380 收藏 8
点赞数 8
分类专栏： C/C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/axyw_/article/details/134639128
版权

1.同步和异步

在这里插入图片描述

同步方式实现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",
    "www.aliyun.com",
    "www.ctrip.com",
    "hotels.ctrip.com",
    "hotels.ctrip.com",
    "vacations.ctrip.com",
    "flights.ctrip.com",
    "trains.ctrip.com",
    "bus.ctrip.com",
    "car.ctrip.com",
    "piao.ctrip.com",
    "tuan.ctrip.com",
    "you.ctrip.com",
    "g.ctrip.com",
    "lipin.ctrip.com",
    "ct.ctrip.com"};

int main(int argc, char *argv[])
{
    int count = sizeof(domain) / sizeof(domain[0]);

    int i = 0;

    for (i = 0; i < count; i++)
    {
        dns_client_commit(domain[i]);
    }
}

king式四元组

  1. commit 提交请求
  2. thread_callback 线程回调函数的实现
  3. init_ctx 初始化
  4. destroy

异步实现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 ASYNC_CLIENT_NUM 1024

#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;
};

struct async_context
{
    int epfd;
    pthread_t thid;
};

typedef void (*async_result_cb)(struct dns_item *list, int count);

struct ep_arg
{
    int sockfd;
    async_result_cb cb;
};

static int set_block(int fd, int block)
{
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags < 0)
        return flags;

    if (block)
    {
        flags &= ~O_NONBLOCK;
    }
    else
    {
        flags |= O_NONBLOCK;
    }

    if (fcntl(fd, F_SETFL, flags) < 0)
        return -1;

    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 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",
    "www.aliyun.com",
    "www.ctrip.com",
    "hotels.ctrip.com",
    "hotels.ctrip.com",
    "vacations.ctrip.com",
    "flights.ctrip.com",
    "trains.ctrip.com",
    "bus.ctrip.com",
    "car.ctrip.com",
    "piao.ctrip.com",
    "tuan.ctrip.com",
    "you.ctrip.com",
    "g.ctrip.com",
    "lipin.ctrip.com",
    "ct.ctrip.com"};

void dns_async_client_free_domains(struct dns_item *list, int count)
{
	int i = 0;

	for (i = 0; i < count; i++)
	{
		free(list[i].domain);
		free(list[i].ip);
	}

	free(list);
}

int dns_async_client_destroy(struct async_context *ctx)
{
    if (ctx == NULL)
		return -1;

	pthread_cancel(ctx->thid);
	close(ctx->epfd);

	return 0;
}

static void *dns_saync_callback_func(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);

            close(sockfd);
			dns_async_client_free_domains(domain_list, count);
            free(data);
        }
    }
    // dns_async_client_destroy(ctx);
}

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 *)malloc(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);
    return ret;
}

int dns_async_client_init(struct async_context *ctx)
{
    if (ctx == NULL)
        return -1;
    ctx->epfd = epoll_create(1);

    pthread_t thread_id;
    int ret = pthread_create(&thread_id, NULL, dns_saync_callback_func, ctx);

    if (ret)
    {
        perror("pthread_create");
        return -1;
    }

    ctx->thid = thread_id;
    return 0;
}

int main(int argc, char *argv[])
{

    struct async_context *ctx = (struct async_context *)malloc(sizeof(struct async_context));
    dns_async_client_init(ctx);

    int count = sizeof(domain) / sizeof(domain[0]);

    int i = 0;

    for (i = 0; i < count; i++)
    {
        dns_async_client_commit(ctx, domain[i], dns_async_client_result_callback);
    }

    getchar();
}
毛毛不怕困难
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
池化组件之异步请求池
Aaron.无剑
07-31 1156
1 解决问题 当服务器操作需求请求一些资源，例如mysql，redis，dns，http等时，如果不采用任何池化组件，就是基本上都是经过tcp三次握手，认证 ，然后再操作，关闭认证，tcp四次挥手。这就是一个耗时的事情，如果再加上业务服务器频繁操作就更加耗时。 就引入了连接池(服务器启动后，提前创建好固定的连接，然后进行同步操作)；当服务器业务处理增加量后，此时就可以在连接池中，加入连接的放缩来处理也是可以处理并发的。 也还有另外一种方案：异步请求池 2 同步和异步区别 同步：服务器发送了请求必须要等待第三
涌动：涌动是一种微服务引擎，提供轻量，高性能，模块化的RPC请求管道。 服务引擎支持http，TCP，WS，Grpc，Thrift，Mqtt，UDP和DNS协议。 它使用ZooKeeper和Consul作为注册表，并将其集成。 哈希，随机，轮询，公平轮询作为负载平衡算法，内置服务管理以确保可靠的RPC通信，引擎包含诊断程序，协议和中间件调用的链接跟踪以及集成的SkyWalking分布式APM
02-28
提供高性能的RPC远程服务调用，采用Zookeeper，Consul作为surging服务的注册中心，集成了哈希，随机，替代，压力最小优先负载均衡的算法，RPC可以选择采用netty或Thrift框架，采用异步非双重传输。 名字由来 英文...
学习 连接池，线程池，内存池，异步请求池 ，学会实现异步效果
QNBZ的博客
08-10 824
如何实现异步，内存泄漏怎么查，任务队列为空工作线程怎么处理，mysql，redis连接池如何实现，线程池如何设计，池式结构的好处
异步请求池
EquinoxM的博客
03-28 949
请求组件： 1. 线程池 2. 协程 3. 异步请求池 请求第三方服务：以mysql为例： 客户端send请求给业务服务器，业务服务器收到后进行解析，解析后调用mysql_query(sql)执行sql语句请求mysql服务器返回数据，这个请求mysql服务器请求时间很长，要等mysql服务器数据的返回才继续往下执行，否则就是阻塞状态。在单线程里面如果发多个请求，这些请求就是串行的，会很慢。 异步请求：每次发完请求后不等待结果的返回，直接去干其他的事情，用一个线程去专门接收mysql数据库的返回。这样就实现
OkHttp源码解析（一）同步请求和异步请求
zhaojun的博客
03-14 1万+
接下来几篇文章，将会进行OkHttp的源码解析。还记得去年花了半天时间去进行Volley的源码解析，其实去年那篇文章我也说过，Volley已经算是一个过时的网络请求框架。因此，接下来，我会选择主流的网络请求框架OkHttp进行源码解析。今天，主要从OkHttp的两种请求方式开始说起，也就是同步请求和异步请求。 一、前言 作为一名优秀的程序员，一定要有分析源码的经...
网络请求框架：Okhttp：Dispatcher分发器实现同步异步请求源码解析【三】
C++ JAVA的专栏
03-21 2161
OKHttp3--Dispatcher分发器实现同步异步请求源码解析【三】_没有鱼了的博客-CSDN博客_okhttp3.dispatcher
[Android] 主流网络请求框架 OkHttp 全方位详析
weixin_74863998的博客
03-28 2058
OkHttp 是一个由 Square 公司开源的 HTTP 客户端库，本文将介绍 OkHttp 的简单用法，并从源码的角度分析 Dispathcer 和 Interceptors 的执行流程及原理。
网络请求框架：OkHttp：框架解析
C++ JAVA的专栏
01-24 958
> 网络框架 OkHttpInterceptor 是OkHttp最核心的一个东西，不要误以为它只负责拦截请求进行一些额外的处理（例如 cookie），实际上它把实际的网络请求、缓存、透明压缩等功能都统一了起来，每一个功能都只是一个 Interceptor，它们再连接成一个 Interceptor.Chain，环环相扣，最终圆满完成一次网络请求。 责任链拦截器Interceptor： RetryAndFollowUpInterceptor:负责失败重试以及重定向； BridgeIntercepto...
Android异步HTTP请求框架Volley的使用
small-dream的博客
07-28 3707
原文地址：http://arnab.ch/blog/2013/08/asynchronous-http-requests-in-android-using-volley/# Volley是Android 开发者的一把“瑞士军刀”，它提供了一些好的工具让在Android 开发中使用网络请求更快，更便捷。Volley的优点在于它封装了HTTP请求的底层实现，让开发者更加专注地写出优雅干净的REST
Android-详解网络请求框架-OkHttp（源码）
q1210249579的博客
12-06 1550
前言 1.OkHttp的优点 网络方面 （1）它支持http2.0，在网络请求响应方面使用了多路复用； （2）内置连接池，减少连接开销，复用连接； （3）内有Response缓存，缓存响应，避免重复的请求； （4）对响应体支持gzip压缩,使得传输数据更为轻量； （5）支持SPDY,允许连接同一主机的所有请求分享一个socket； 拓展方面 （1）支持重定向，重试请求，重写编码拦截器； （2）支持头部信息拦截，自带CookieJar方法； （3）支持网络数据传输时的监听； （4）通过需求能自定义拦截器进行处
vert.x详细介绍，全异步框架
热门推荐
远方的行者
02-15 4万+
Vert.x是一个基于JVM、轻量级、高性能的应用平台，非常适用于最新的移动端后台、互联网、企业应用架构。Vert.x基于全异步Java服务器Netty，并扩展出了很多有用的特性 github:  https://github.com/vert-x3 介绍： Vert.x诞生于2011年，当时叫node.x，不过后来因为某些原因改名位Vert.x。经过三年多的发展，现在已经到了3.2
async：一个很棒的用于Ruby的异步事件驱动的React堆
02-02
异步是基于和的可组合的Ruby异步I / O框架。 “最近我一直在研究async ，因为我的项目之一将从非阻塞I / O中真正受益。它的设计精美。” – 产品特点 可扩展的事件驱动的Ruby I / O。 每个流程有数千个客户！ 轻量...
大型网站架构一览从底层到前端技术框架分析.pdf
11-28
- **负载均衡**：将用户请求分散到多台应用服务器，以应对高并发。 - **Session管理**：通过分布式Session管理，确保会话在集群中的共享和一致性。 - **动态页面静态化**：对访问量大但更新不频繁的页面进行静态...
大型网站架构一览从底层到前端技术框架分析.docx
11-28
此外，【DNS】在大型网站架构中扮演重要角色，通过DNS负载均衡可以将用户请求分散到不同的服务器，同时配置CDN也需要DNS的配合。 为了应对高并发访问，网站会采用【应用服务器集群】，通过负载均衡技术将用户请求...
渲染篇 4：千方百计——Event Loop 与异步更新策略(1).md
04-01
我们现在站在性能优化的角度，一起简单地复习一遍这个经典的过程：首先我们需要通过 DNS（域名解析系统）将 URL 解析为对应的 IP 地址，然后与这个 IP 地址确定的那台服务器建立起 TCP 网络连接，随后我们向服务端抛...
C++ 72 之 友元和类模版
LSG_Down的博客
06-18 270
【代码】C++ 72 之 友元和类模版。
11.5.k8s中pod的调度-cordon，drain，delete
qq_22321199的专栏
06-17 624
-ignore-daemonsets #daemonset资源不能被驱逐，需要排除，加这个选项参数排除；--delete-emptydir-data #如果无法驱逐成功，再加这个参数；
什么野指针（c++）
最新发布
qq_35374791的博客
06-24 2250
野指针（Wild Pointer）是指向不确定位置或者非法地址的指针。当一个指针指向的内存被释放后，如果没有将其设置为NULL，那么这个指针就变成了野指针。使用野指针会导致未定义行为，可能引发程序崩溃或数据损坏。
VS C++常用错误与解决方法
知来者逆的博客
06-18 672
常见vs c++错误解决方法
藏经阁-QQ移送页面框架优化实践.pdf
08-28
可以采取一系列措施，如启动流程优化以减少终端耗时，预加载进程，实现懒加载和IO异步化，利用WebView池来复用和预创建WebView，减少新实例的创建时间，以及通过DNS预解析和离线预推来提升网络请求效率。 - 页面...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值