memcached网络层操作详解

最新推荐文章于 2019-06-30 06:04:36 发布
最新推荐文章于 2019-06-30 06:04:36 发布
阅读量149 收藏
点赞数
分类专栏： 开源分析 文章标签： memcached
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/igaozh/article/details/84292630
版权

[liexusong原创]

memcached的网络层处理大概如下:

memcached网络层操作详解1

(1)  main函数创建一个侦听服务端的socket, 然后添加到libevent中, 然后当有客户端连接时就会触发libevent事件, 并且调用drive_machine()函数, 就像上面图一样.

(2)  drive_machine()函数会根据conn的state字段来判断一个要进行什么操作. memcached中有7种的操作状态, 定义如下:

 

enum conn_states {

    conn_listening, 

    conn_read,      

    conn_write,     

    conn_nread,     

    conn_swallow,   

    conn_closing,   

    conn_mwrite     

};

 

drive_machine()函数大概如下:

void drive_machine(conn *c) {

    int exit = 0;

    int sfd, flags = 1;

    socklen_t addrlen;

    struct sockaddr addr;

    conn *newc;

    int res;

 

    while (!exit) {

        switch(c->state) {

        case conn_listening:

            addrlen = sizeof(addr);

            if ((sfd = accept(c->sfd, &addr, &addrlen)) == -1) {

                if (errno == EAGAIN || errno == EWOULDBLOCK) {

                    exit = 1;

                    break;

                } else {

                    perror("accept()");

                }

                break;

            }

            //设置socket为非阻塞

            if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 ||

                fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {

                perror("setting O_NONBLOCK");

                close(sfd);

                break;

            }

 

            newc = conn_new(sfd, conn_read, EV_READ | EV_PERSIST);

            if (!newc) {

                if (settings.verbose > 0)

                    fprintf(stderr, "couldn't create new connection\n");

                close(sfd);

                break;

            }

 

            break;

        case conn_read:

            if (try_read_command(c)) {

                continue;

            }

            if (try_read_network(c)) {

                continue;

            }

           

            if (!update_event(c, EV_READ | EV_PERSIST)) {

                if (settings.verbose > 0)

                    fprintf(stderr, "Couldn't update event\n");

                c->state = conn_closing;

                break;

            }

            exit = 1;

           break;

            … … …

        }

        … … …

    }

}

 

drive_machine()函数大概就是根据conn *c的state字段来判断要进行的操作. 每个客户端连接到memcached之后都会把他添加到libevent, 然后就触发事件调用这个函数. 所以说这个函数是最重要的.

 

[1]conn_listening状态:

这个状态主要是侦听客户端连接, 把他设置为非阻塞, 然后通过调用conn_new()函数把他放到libevent中. conn_new()函数大概如下:

conn *conn_new(int sfd, int init_state, int event_flags) {

    conn *c;

 

   

if (freecurr > 0) {

        //如果在freeconns中有数据, 直接去freeconns中取

        c = freeconns[--freecurr];

    } else {

        if (!(c = (conn *)malloc(sizeof(conn)))) {

            perror("malloc()");

            return 0;

        }

        c->rbuf = c->wbuf = 0;

        c->ilist = 0;

 

        c->rbuf = (char *) malloc(DATA_BUFFER_SIZE);//2048

        c->wbuf = (char *) malloc(DATA_BUFFER_SIZE);//2048

       

        c->ilist = (item **) malloc(sizeof(item *)*200);//分配200个item指针

 

        //分配内存失败?

        if (c->rbuf == 0 || c->wbuf == 0 || c->ilist == 0) {

            if (c->rbuf != 0) free(c->rbuf);

            if (c->wbuf != 0) free(c->wbuf);

            if (c->ilist !=0) free(c->ilist);

            free(c);

            perror("malloc()");

            return 0;

        }

       

        c->rsize = c->wsize = DATA_BUFFER_SIZE;//2048

        c->isize = 200;

        stats.conn_structs++;//状态中增加一个conn

    }

 

    if (settings.verbose > 1) {

        if (init_state == conn_listening)

            fprintf(stderr, "<%d server listening\n", sfd);

        else

            fprintf(stderr, "<%d new client connection\n", sfd);

    }

 

    c->sfd = sfd;//保存socket文件描述符

    c->state = init_state;//初始化的处理状态

    c->rlbytes = 0;

    c->rbytes = c->wbytes = 0;

    c->wcurr = c->wbuf;//指向当前的缓存位置

    c->rcurr = c->rbuf;

    c->icurr = c->ilist;

    c->ileft = 0;

    c->iptr = c->ibuf;

    c->ibytes = 0;

 

    c->write_and_go = conn_read;//写完后进行读操作

    c->write_and_free = 0;

    c->item = 0;

 

    c->is_corked = 0;

 

    //设置event事件

    event_set(&c->event, sfd, event_flags, event_handler, (void *)c);

    c->ev_flags = event_flags;

 

    if (event_add(&c->event, 0) == -1) {

        free(c);

        return 0;

    }

 

    stats.curr_conns++;

    stats.total_conns++;

 

    return c;

}

 

conn_new()函数主要是新建一个conn对象, 并且初始化他的属性.

 

 

[2]conn_read状态:

状态conn_read处理中有两个函数比较重要, 就是try_read_network() 和try_read_command(). try_read_network()是从网络端处读取数据, 当读到足够的数据时调用try_read_command()来处理数据, try_read_command()函数调用parse_command()函数来解析命令, 然后根据命令的类型来改变连接的状态.

 

try_read_network()函数如下:

int try_read_network(conn *c) {

    int gotdata = 0;

    int res;

    while (1) {

        if (c->rbytes >= c->rsize) {

            char *new_rbuf = realloc(c->rbuf, c->rsize*2);

            if (!new_rbuf) {

                if (settings.verbose > 0)

                    fprintf(stderr, "Couldn't realloc input buffer\n");

                c->rbytes = 0;

                out_string(c, "SERVER_ERROR out of memory");

                c->write_and_go = conn_closing;

                return 1;

            }

            c->rbuf = new_rbuf; c->rsize *= 2;

        }

        res = read(c->sfd, c->rbuf + c->rbytes, c->rsize - c->rbytes);

        if (res > 0) {

            stats.bytes_read += res;

            gotdata = 1;

            c->rbytes += res;

            continue;

        }

        if (res == 0) {

           

            c->state = conn_closing;

            return 1;

        }

        if (res == -1) {

            if (errno == EAGAIN || errno == EWOULDBLOCK) break;

            else return 0;

        }

    }

    return gotdata;

}

 

这个函数的主要操作是, 从客服端处读取数据, 直到没有数据可读为止[res == -1 &&  (errno == EAGAIN || errno == EWOULDBLOCK)]. 读取数据的同时改变conn的rbytes字段, 表示已经读到的数据大小. 当read()调用返回0时表示连接已经断开, 修改连接的状态为关闭, 下次操作会从libevent中去掉.

 

try_read_command()函数如下:

int try_read_command(conn *c) {

    char *el, *cont;

 

    if (!c->rbytes)

        return 0;

    el = memchr(c->rbuf, '\n', c->rbytes);

    if (!el)

        return 0;

    cont = el + 1;

    //略过\r\n

    if (el - c->rbuf > 1 && *(el - 1) == '\r') {

        el--;

    }

    *el = '\0';

 

    process_command(c, c->rbuf);

 

    if (cont - c->rbuf < c->rbytes) {

        memmove(c->rbuf, cont, c->rbytes - (cont - c->rbuf));

    }

    c->rbytes -= (cont - c->rbuf);

    return 1;

}

 

try_read_command()函数主要是当从客户端读取的数据足够时才会处理的, 就是当读到有换行符\n时才会处理, 因为命令一般是以换行符结束的. 然后通过调用process_command()来解析命令. 解析完命令后, 把命令从缓存中去掉, 剩下剩余的数据, 操作如下:

if (cont - c->rbuf < c->rbytes) {

    memmove(c->rbuf, cont, c->rbytes - (cont - c->rbuf));

}

效果如下图:

memcached网络层操作详解1

其中绿色段是数据, 黄色段是命令, 处理完命令后, 会用数据段把命令段覆盖, 是通过memmove(c->rbuf, cont, c->rbytes - (cont - c->rbuf));这条语句来处理的.

process_command()函数如下:

void process_command(conn *c, char *command) {

   

    int comm = 0;

    int incr = 0;

 

   

 

    if (settings.verbose > 1)

        fprintf(stderr, "<%d %s\n", c->sfd, command);

 

   

    set_cork(c, 1);

 

    if ((strncmp(command, "add ", 4) == 0 && (comm = NREAD_ADD)) ||

        (strncmp(command, "set ", 4) == 0 && (comm = NREAD_SET)) ||

        (strncmp(command, "replace ", 8) == 0 && (comm = NREAD_REPLACE))) {

 

        char key[251];

        int flags;

        time_t expire;

        int len, res;

        item *it;

 

        //<command name> <key> <flags> <exptime> <bytes>\r\n

        //忽略command

        res = sscanf(command, "%*s %0s %u %lu %d\n", key, &flags, &expire, &len);

        if (res!=4 || strlen(key)==0 ) {

            out_string(c, "CLIENT_ERROR bad command line format");

            return;

        }

        expire = realtime(expire);

        it = item_alloc(key, flags, expire, len+2);//alloc new item

        if (it == 0) {

            out_string(c, "SERVER_ERROR out of memory");

           

            c->write_and_go = conn_swallow;

            c->sbytes = len+2;

            return;

        }

 

        c->item_comm = comm;

        c->item = it;

        c->rcurr = ITEM_data(it);//point to item data area (指向item的数据域)

        c->rlbytes = it->nbytes;

        c->state = conn_nread;

        return;

}

… …

}

 

process_command()函数主要是解析命令, 然后进行制定的操作. 如上代码, 就是处理add/set/replace命令的操作.最后完成add/set/replace操作后, 会把连接的状态设置为conn_nread. conn_nread状态的操作是从客户端中读取完整的数据. 然后完成add/set/replace的所有操作, 如把数据存储在item中, 并且连接这个item. 最后把conn的rcurr指针指向item的数据域. 这样做是为了下面的conn_nread操作时可以直接把数据读到item的数据域中.

 

[3]conn_nread状态:

conn_nread状态是要从客户端连接处读取没有读完的数据, 并且把数据放到在conn_read状态时的item的数据域中.

 

 

[4]conn_write状态:

说conn_write状态之前先要说说out_string()函数, 定义如下:

void out_string(conn *c, char *str) {

    int len;

 

    if (settings.verbose > 1)

        fprintf(stderr, ">%d %s\n", c->sfd, str);

 

    len = strlen(str);

    if (len + 2 > c->wsize) {

       

        str = "SERVER_ERROR output line too long";

        len = strlen(str);

    }

 

    strcpy(c->wbuf, str);

    strcat(c->wbuf, "\r\n");

    c->wbytes = len + 2;

    c->wcurr = c->wbuf;

 

    c->state = conn_write;

    c->write_and_go = conn_read;

    return;

}

 

就是把str字符串写到conn的wbuf缓存中, 然后设置conn的状态为conn_write, 表示下次操作要进行conn_write相关的操作, 最后设置conn的write_and_go为conn_read, 表示写操作完毕以后要进行读操作.

 

而conn_write状态对应的操作就是: 把wbuf缓存的数据写到客户端连接处, 操作如下:

case conn_write:

   

   

    if (c->wbytes == 0) {

        if (c->write_and_free) {

            free(c->write_and_free);

            c->write_and_free = 0;

        }

        c->state = c->write_and_go;

        if (c->state == conn_read)

            set_cork(c, 0);

        break;

    }

    res = write(c->sfd, c->wcurr, c->wbytes);

    if (res > 0) {

        stats.bytes_written += res;

        c->wcurr  += res;

        c->wbytes -= res;

        break;

    }

    if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {

        if (!update_event(c, EV_WRITE | EV_PERSIST)) {

            if (settings.verbose > 0)

                fprintf(stderr, "Couldn't update event\n");

            c->state = conn_closing;

            break;

        }               

        exit = 1;

        break;

    }

   

    if (settings.verbose > 0)

        fprintf(stderr, "Failed to write, and not due to blocking\n");

    c->state = conn_closing;

    break;

 

conn_write状态操作一般是调用out_string()函数设置的, 作用一般都是把一些消息发给客户端连接. 调用out_string()函数一般会立即执行conn_read状态对应的操作. 因为out_string()没有修改libevent的事件, 所以要立即执行conn_read状态对应的操作才行, 不然就不会触发相关的事件. 而执行conn_read状态操作时, 如果客户端不可写(write调用返回-1, 并且errno == EAGAIN || errno == EWOULDBLOCK), 那么就会修改libevent的事件为写(EV_WRITE) [ update_event(c, EV_WRITE | EV_PERSIST)], 之后就等libevent事件触发才再次执行conn_write状态对应的操作了.

 

[5]conn_mwrite状态:

conn_mwrite状态是当用户要执行get命令时设置的. get命令处理如下:

if (strncmp(command, "get ", 4) == 0) {

 

    char *start = command + 4;

    char key[251];

    int next;

    int i = 0;

    item *it;

    time_t now = time(0);

 

    while(sscanf(start, " %0s%n", key, &next) >= 1) {

        start+=next;

        stats.get_cmds++;

        it = assoc_find(key);

        if (it && (it->it_flags & ITEM_DELETED)) {

            it = 0;

        }

        if (settings.oldest_live && it &&

            it->time <= settings.oldest_live) {

            it = 0;

        }

        if (it && it->exptime && it->exptime < now) {

            item_unlink(it);

            it = 0;

        }

 

        if (it) {

            stats.get_hits++;

            it->refcount++;

            item_update(it);

            *(c->ilist + i) = it;

            i++;

            if (i > c->isize) {

                c->isize *= 2;

                c->ilist = realloc(c->ilist, sizeof(item *)*c->isize);

            }

        } else stats.get_misses++;

    }

    c->icurr = c->ilist;

    c->ileft = i;

    if (c->ileft) {

        c->ipart = 0;

        c->state = conn_mwrite;

        c->ibytes = 0;

        return;

    } else {

        out_string(c, "END");

        return;

    }

}

 

此操作主要是根据用户提供的key来查找相关的item, 并且把item方法conn的item列表中供conn_mwrite状态操作时使用.

 

conn_mrwrite操作时最复杂的, 代码如下:

case conn_mwrite:

   

    if (c->ibytes > 0) {

        res = write(c->sfd, c->iptr, c->ibytes);

        if (res > 0) {

            stats.bytes_written += res;

            c->iptr += res;

            c->ibytes -= res;

            break;

        }

        if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {

            if (!update_event(c, EV_WRITE | EV_PERSIST)) {

                if (settings.verbose > 0)

                    fprintf(stderr, "Couldn't update event\n");

                c->state = conn_closing;

                break;

            }

            exit = 1;

            break;

        }

       

        if (settings.verbose > 0)

            fprintf(stderr, "Failed to write, and not due to blocking\n");

        c->state = conn_closing;

        break;

    } else {

 

        item *it;

       

        switch (c->ipart) {

        case 1:

            it = *(c->icurr);

            assert((it->it_flags & ITEM_SLABBED) == 0);

            c->iptr = ITEM_data(it);

            c->ibytes = it->nbytes;

            c->ipart = 2;

            break;

        case 2:

            it = *(c->icurr);

            item_remove(it);

            c->ileft--;

            if (c->ileft <= 0) {

                c->ipart = 3;

                break;

            } else {

                c->icurr++;

            }

           

        case 0:

            it = *(c->icurr);

            assert((it->it_flags & ITEM_SLABBED) == 0);

            sprintf(c->ibuf, "VALUE %s %u %u\r\n", ITEM_key(it), it->flags, it->nbytes - 2);

            if (settings.verbose > 1)

                fprintf(stderr, ">%d sending key %s\n", c->sfd, ITEM_key(it));

            c->iptr = c->ibuf;

            c->ibytes = strlen(c->iptr);

            c->ipart = 1;

            break;

        case 3:

            out_string(c, "END");

            break;

        }

    }

    break;

 

这个操作主要是把get命令处获取到的item的数据发送到客户端连接.

主要难点是: conn_mwrite操作是遍历所有获取到的item, 然后把item的数据发送给客户端.

 

遍历的时候使用了一个switch来处理, 主要有4中情况, 如下:

(1) 0是发生key和数据的信息.

(2) 1是发生数据data.

(3) 2是减少item的refcount和把当前item指针向后移动一个, 并且继续执行(1)的操作.

(4) 3是完成操作.

 

每次ibuf有数据的时候都会进行写操作, 代码如下:

    if (c->ibytes > 0) {

        res = write(c->sfd, c->iptr, c->ibytes);

        if (res > 0) {

            stats.bytes_written += res;

            c->iptr += res;

            c->ibytes -= res;

            break;

        }

        if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {

            if (!update_event(c, EV_WRITE | EV_PERSIST)) {

                if (settings.verbose > 0)

                    fprintf(stderr, "Couldn't update event\n");

                c->state = conn_closing;

                break;

            }

            exit = 1;

            break;

        }

       

        if (settings.verbose > 0)

            fprintf(stderr, "Failed to write, and not due to blocking\n");

        c->state = conn_closing;

        break;

    }

 

当ibuf没有数据时, 才会遍历从get命令操作取得的item列表, 并取得数据复制到ibuf中.

 

[6] conn_swallow状态:

conn_swallow状态是当内存不足并且调用add/set/replace命令的时候才会出现, 此操作主要是读取客户端发送过来的数据, 并且忽略掉. 操作如下:

case conn_swallow:

   

    if (c->sbytes == 0) {

        c->state = conn_read;

        break;

    }

 

   

    if (c->rbytes > 0) {

        int tocopy = c->rbytes > c->sbytes ? c->sbytes : c->rbytes;

        c->sbytes -= tocopy;

        if (c->rbytes > tocopy) {

            memmove(c->rbuf, c->rbuf+tocopy, c->rbytes - tocopy);

        }

        c->rbytes -= tocopy;

        break;

    }

 

   

    res = read(c->sfd, c->rbuf, c->rsize > c->sbytes ? c->sbytes : c->rsize);

    if (res > 0) {

        stats.bytes_read += res;

        c->sbytes -= res;

        break;

    }

    if (res == 0) {

        c->state = conn_closing;

        break;

    }

    if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {

        if (!update_event(c, EV_READ | EV_PERSIST)) {

            if (settings.verbose > 0)

                fprintf(stderr, "Couldn't update event\n");

            c->state = conn_closing;

            break;

        }

        exit = 1;

        break;

    }

   

    if (settings.verbose > 0)

        fprintf(stderr, "Failed to read, and not due to blocking\n");

    c->state = conn_closing;

    break;


至此memcached所有的网络层操作已经全部分析完.
igaozh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
memcached学习笔记（二）
一堆瓜子壳
03-15 447
经过这几天的学习，要将RDMA移植到memcached上，主要有下面3个方面的工作需要完成： 1、TCP连接到QP(Queue Pair)的创建 Memcached在建立网络连接时，只是使用socket创建了TCP的数据链路；而使用RDMA时还需要在客户端和服务器端创建SQ和RQ队列并创建指针指向注册内存区域。 2、Get和Set操作 数据库最主要的操作就是查询和插入，对应于Get和Set
memcached之网络模型详解
一个菜鸟的博客
05-08 1058
综述 主线程创建多个子线程(这些子线程也称为worker线程)，每一个线程都维持自己的事件循环，即每个线程都有自己的epoll，并且都会调用epoll_wait函数进入事件监听状态。每一个worker线程(子线程)和主线程之间都用一条管道相互通信。每一个子线程都监听自己对应那条管道的读端。当主线程想和某一个worker线程进行通信，直接往对应的那条管道写入数据即可。 模型的工作流程：主线程负责...
memcached的执行流程
tz_sz的专栏
11-20 966
memcached的执行流程 1、libevent的使用方法 初始化   main_base = event_init();  //多孔插座 事件设置 event_set(&ev, listen_fd, EV_READ | EV_PERSIST, cb, *arg) //设置灯泡                   event_base_set(main_base, &ev);//设置灯泡
memcached源码剖析——流程图
weixin_30642029的博客
07-28 75
参考： http://blog.csdn.net/column/details/memcached-src.html http://calixwu.com/2014/11/memcached-yuanmafenxi.html 转载于:https://www.cnblogs.com/070412-zwc/p/7251038.html
Memcached源码分析之状态机（二）
lc的大脑备份
03-24 2951
Memcached业务状态机，读取（TCP和UDP）网络数据，看看memcached怎么使用网络缓冲区读取TCP数据。
Memcached 原理和使用详解
02-12
1. **基于C/S架构**：Memcached采用客户端-服务器模型，客户端应用程序通过网络发送请求到Memcached服务器，服务器处理请求并返回结果。这种架构使得Memcached易于部署和扩展。 2. **简单的协议**：Memcached使用...
memcached服务器软件
07-16
**Memcached服务器软件详解** Memcached是一款高性能、分布式内存对象缓存系统，广泛应用于Web应用中，用于减轻数据库负载，提高数据访问速度。它的工作原理是将数据存储在内存中，以便快速检索，从而实现高速的...
memcached 分布式内存
09-04
**Memcached 分布式内存详解** Memcached 是一套由 danga.com 开发的高效、分布式的内存对象缓存系统，其主要目标是在高流量的动态应用程序中减轻数据库的负载，从而提升整体系统的性能。这套系统的工作原理是将...
Memcached 的安装
05-18
**Memcached 安装详解** Memcached 是一款高性能的分布式内存对象缓存系统，主要用于减少数据库负载，提高动态应用的访问速度。它由 Danga Interactive 开发，最初应用于提升 LiveJournal.com 的页面访问速度，现在...
利用memcached构建高性能的Web应用程序[归纳].pdf
10-13
8. **Memcached的适用场景**：适用于需要快速读取大量相同数据的Web应用，如社交网络、视频分享平台等，通过缓存减少对数据库的依赖，提高响应速度。 9. **扩展应用**：除了Memcached，还有其他类似的分布式缓存...
memcached的学习（9）
Zuoerfeng
11-21 165
2018.6.14 之前学习了memcached的网络模型，主要是服务于多个客户端TCP连接的网络模型创建，也是CS架构上我们值得学习的一个模型，在设计网络模型的时候可以学习这种框架。今天来学习memcached的命令解析，也就是接收到了网络传来的数据包，按照不同的命令解析，并调用不同的功能模块。 ———————————————————————————————————————————— 我们回顾上...
memcached的连接处理
tz_sz的专栏
11-21 2083
一、相关结构 enum conn_states { conn_listening, /**< the socket which listens for connections */ conn_new_cmd, /**< Prepare connection for next command */ conn_waiting, /**< waiting for
memcached安装失败
lynAnn的专栏
08-18 7431
系统：win10 32位 memcached在Windows环境上的下载与安装配置 转载于：http://blog.csdn.net/wyc_cs/article/details/25881741 1.Windows版本的下载地址为： http://download.csdn.net/detail/wyc_cs/7575375 将压缩文件解压到  e:/memc
Memcached学习（三）--消息回应
weixin_30555753的博客
03-29 134
conn结构主要是存储单个客户端的连接详情信息。每一个客户端连接到Memcached都会有这么一个数据结构。 typedef struct conn conn; struct conn { //.... /* data for the mwrite state */ //iov主要存储iov的数据结构 //iov数据结构会在conn_new中初始化，...
强化学习用于 深度神经网络架构搜寻
qq_37567000的博客
12-20 1392
论文：NEURAL ARCHITECTURE SEARCH WITH REINFORCEMENT LEARNING 随着深度神经网络在各应用场景上大放异彩，如何自动搜索优秀的深度网络架构以及超参，也成为了一个热门研究点。本文介绍的论文就是通过强化学习，来进行深度网络的架构搜索。 全文的整体概览如下图所示，一个基于RNN的controller用于搜索和生成架构，然后使用强化学习中的polic...
一个简单的js特效,点击放大图片
Petter_Mo的专栏
04-23 4578
html页面的源代码http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">http://www.w3.org/1999/xhtml">点击小图看大图style="PADDING-RIGHT: 0px; PADDING-LEFT: 0px; FLOAT: left; PADDING-TOP: 0px" onclick="Pop(th
memcached set命令的大致处理逻辑笔记
weixin_34050389的博客
06-30 418
这次记录状态机的主要逻辑，跟踪set命令的执行流程，暂不涉及到内存申请这一块，下面内容基本都是代码注释 首先还是补充了解下客户连接在发送数据到数据被处理并返回过程中conn的各种状态的表示 enum conn_states { conn_listening, /** 只有监听连接的socket才会是这种状态*/ conn_new_cmd, /** 等待下一条命令，新建的客户端连接初始化...
分布式缓存系统Memcached(九)——状态机之socket连接与派发
艰难困苦如同欢乐，终将成为人生最后的财富
01-25 1348
Memcached主线程中监听socket注册事件和工作线程中连接socket注册事件的回调函数都是event_handler，且event_handler的核心部分都是一个有限状态机：drive_machine。因此接下来将对该状态机具体的业务处理进行深入的剖析。 memcached将每个socket都封装为一个conn结构体，该结构体包含了比如socket的文件描述符sfd、注册事件event、连接状态结构体conn_states，等等诸多信息字段，其中的状态结构：conn_states中包含了该so
Memcached：分布式内存缓存系统详解与操作指南
libevent的强大功能使得Memcached能够有效地管理网络连接，提供高效的I/O操作。 此外，Memcached的核心特性之一是其内置的内存管理机制，采用Slab Allocation策略来优化内存使用。这种机制通过预先分配并分组内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值