Redis 协议与异步方式

摸鱼呀

已于 2022-10-31 09:09:19 修改

阅读量488

点赞数

分类专栏： linux_中间件开发文章标签： redis 网络协议 linux

于 2022-10-17 20:35:55 首次发布

本文链接：https://blog.csdn.net/you_fathe/article/details/127375401

版权

linux_中间件开发专栏收录该内容

19 篇文章 2 订阅

订阅专栏

文章目录

1、redis 网络

1.1、redis 网络

微观上：reactor

组成：IO 多路复用 + 非阻塞 IO
IO 职责：IO 检测和 IO 操作
事件：异步事件处理流程，先注册事件，事件循环中处理事件 callback

宏观上：可以忽略其他流程，只关注数据包处理流程。当管道（连接）构成一个完整的包，处理事件。

1.2、redis 协议

redis 协议设计

消息边界：字符流头部 + 分隔符
消息类型：字符串的第一个字符。

redis 采用 RESP 序列化协议，协议的不同部分使用以CRLF(\r\n) 结束。

RESP 支持的数据类型，通过第一个字符判断数据类型

+ Simple Strings
```
+OK\r\n
```
- Errors：
```
-Error <message>\r\n
```
: Integers
```
:<数值>\r\n
```
$ Bulk Strings
```
$<数据长度>\r\n<数据内容>\r\n
```

* Arrays

*<元素个数n>\r\n<元素内容>...<元素n>

RESP 在 redis 请求-响应协议中的作用方式

客户端发送字符串数组 ( Array + Bulk Strings) 到 redis 服务器

*<参数数量>\r\n$<参数1的长度>\r\n<参数1的数据>\r\n...$<参数n的长度>\r\n<参数n的数据>\r\n

redis 服务器根据命令实现回复一种 RESP 数据类型到客户端。

来看下面例子

在 redis-cli，发送一条命令 set key value，对应的报文为：

*3\r\n$3\r\nset\r\n$3\r\nkey\r\n$5\r\nvalue

执行成功 OK，回应的报文为：

+OK\r\n

若执行失败，回应的报文为

-ERR unknown command `ket`, with args beginning with: `key`, `value`, \r\n

2、redis pipline

redis pipline 是 redis 客户端提供的机制，与 redis 本身无关，是为了节约网络传输时间而设计的。具体来说，客户端一次性发送多个请求，redis 服务器按序依次回复，与 http 1.1 类似。

在这里插入图片描述

3、redis 事务

事务：用户定义一系列数据库操作，这些操作视为一个完整的逻辑处理工作单元，要么全部执行，要么全部不执行，是不可分割的工作单元。

探讨事务的前提：在并发连接的情况下，不同连接异步执行命令造成的不可预期的冲突。

3.1、事务的特征

ACID, Atomicity-Consistency-Isolation-Durability

原子性：事务不可分割，要么全部成功，要么全部失败，如果执行失败必须提供回滚机制。原子操作的原子性，只有执行或不执行，其他线程不可能看到其他状态。而事务的原子性，还包含了回滚操作。
一致性：事务的前后，所有的数据都保持一个一致的状态，不能违反数据的一致性检测。这里的一致性指的是预期的一致性不是异常后的一致性。类型一致性，逻辑一致性，数据一致性（主从数据库一致）
隔离性：并发事务间的要相互隔离。redis 单线程执行，天然具备隔离性。mysql 一条连接对应一个线程。多线程环境下需要对临界资源进行加锁。
持久性：事务一旦提交，对数据的改变就是永久性的，即数据落盘。

3.2、事务命令

redis 客户端以 MULTI 开启一个事务，发送多个命令到服务端的队列，直到发送 EXEC 命令后redis 服务端才会执行队列中的命令，将队列作为一个整体来执行。

# 开启事务
MULTI
# 提交事务
EXEC
# 取消事务
DISCARD
# 监视 key 的变动，在事务开启前调用，乐观锁 cas 实现。若在事务执行中，key 变动则取消事务返回 nil。
WATCH key

实际工作中不会使用，这是因为事务命令是由乐观锁实现的，失败需要重试，会增加业务逻辑的复杂程度。

3.3、lua 脚本

redis 内置 lua 解释器来执行 lua 脚本，通过 lua 脚本实现原子性。l

面试：lua 脚本满足原子性和隔离性，不满足一致性和持久性。

原子性：Lua 脚本通过一个命令执行，脚本中所有的命令一起执行，具有原子性。
一致性：不具备一致性，lua 脚本执行失败，已经成功的命令作用数据库，无法回滚。
隔离性：redis 单线程执行，且 lua 脚本作为单数据包运行。
持久性：不具备持久性，只有在 aof 并且 appendfsync = always 才具备，实际工作不会采用该方法。

3.3.1、命令

# 测试使用
# 执行 lua 脚本
EVAL script numkeys [key...] arg [arg...]

# 实际使用
# 只保存40位哈希字符串，减少数据传输量
# 1、缓存脚本，将用户给定的脚本缓存在服务器中，并返回脚本对应的SHA1校验和（40位字符串）作为结果
SCRIPT LOAD script
# 2、执行缓存的脚本
EVALSHA sha1 numkeys key [key ...] arg [arg ...]

# 附：脚本管理命令
# 检查脚本是否缓存
SCRIPT EXISTS sha1 [sha1...]
# 清除所有脚本缓存
SCRIPT FLUSH
# 强制停止正在运行的脚本，如死循环
SCRIPT KILL

3.3.2、应用

项目启动时，建立redis连接并验证后，先加载所有项目中使用的lua脚本 script load
项目中若需要热更新，通过 redis-cli 执行 script flush。然后可以通过订阅发布功能通知所有服务器重新加载lua脚本
若项目中lua脚本发生阻塞，可通过 script kill 暂停当前阻塞脚本的执行

例：执行加倍操作

set mark 1
# 测试使用
eval "local val=redis.call('get',KEYS[1]);if val then redis.call('set', KEYS[1], 2*val);return 2*val;end;return 0;" 1 mark
(integer) 2
127.0.0.1:6379> eval "local val=redis.call('get',KEYS[1]);if val then redis.call('set', KEYS[1], 2*val);return 2*val;end;return 0;" 1 darren
(integer) 0

# 实际使用
# 1、缓存脚本
script load "local val=redis.call('get',KEYS[1]);if val then redis.call('set', KEYS[1], 2*val);return 2*val;end;return 0;"
"9da2e1ac090f2e1df67087370de115a4291cd0bd"
# 2、执行缓存脚本
evalsha "9da2e1ac090f2e1df67087370de115a4291cd0bd" 1 mark
(integer) 4

4、redia 发布订阅

为了支持消息的多播机制，redis 引入了发布订阅模块，是一种分布式消息队列机制。订阅者通过特定的频道来接收发送者发送至该频道的消息。该机制并不保证消息一定到达，可以采用 stream 方式确保可达。

存在的问题有：发送者发送一条消息，若没有订阅者，则消息直接丢弃。若发送期间，一个订阅者断开连接，那么在断开连接期间消息对于该订阅者来说彻底丢失了。此外，redis 停机重启，pubsub 的消息是不会持久化的，所有的消息被直接丢弃。

4.1、命令

# 向频道发送消息
publish channel message
# 订阅频道
subscribe channel [channel...]
# 取消订阅频道
unsubscribe [channel...]
# 订阅模式
psubscribe pattern [pattern...]
# 退订模式
punsubscribe [pattern...]
# 查看发布与订阅的相关信息
PUBSUB CHANNELS [pattern]

4.2、应用

发布订阅功能一般要重新开启一个连接，这是因为命令连接严格遵循请求回应模式，pubsub 能收到 redis 主动推送的内容。所以实际项目中如果支持 pubsub 的话，需要另开一条连接用于处理发布订阅。

# 一个客户端订阅频道
SUBSCRIBE news.shanxi news.henan news.shandong
# 另一个客户端订阅频道，模式匹配
PSUBSCRIBE news.*
# 向频道发送信息，该频道所有订阅者收到消息
publish news.shanxi 'harmony'

5、redis 异步连接

hiredis 是一个 redis 的 C 客户端库函数，服务端可以使用它来访问 redis 服务器。

5.1、同步连接

同步连接采用阻塞 io 来实现，但是会阻塞当前线程，直至 redis 返回结果。

参考文档：hiredis的使用

例如：访问 redis，并对 counter 实现自增1000次，统计用时。

// gcc redis-test-sync.c -o sync -lhiredis
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <hiredis/hiredis.h>

int current_tick() {
    int t = 0;
    struct timespec ti;
	clock_gettime(CLOCK_MONOTONIC, &ti);
	t = (int)ti.tv_sec * 1000;
	t += ti.tv_nsec / 1000000;
    return t;
}

int main(int argc, char **argv) {
    unsigned int j, isunix = 0;
    redisContext *c;
    redisReply *reply;
    const char *hostname = "127.0.0.1";
    int port = 6379;

    struct timeval timeout = { 1, 500000 }; // 1.5 seconds

    c = redisConnectWithTimeout(hostname, port, timeout);

    if (c == NULL || c->err) {
        if (c) {
            printf("Connection error: %s\n", c->errstr);
            redisFree(c);
        } else {
            printf("Connection error: can't allocate redis context\n");
        }
        exit(1);
    }

    int num = (argc > 1) ? atoi(argv[1]) : 1000;

    int before = current_tick();

    reply = redisCommand(c, "auth 123456");
    freeReplyObject(reply);

    for (int i = 0; i < num; ++i) {
        reply = redisCommand(c, "INCR counter");
        printf("INCR counter: %lld\n", reply->integer);
        freeReplyObject(reply);
    }

    int used = current_tick() - before;

    printf("after %d exec redis command, used %d ms\n", num, used);

    /* Disconnects and frees the context */
    redisFree(c);

    return 0;
}

5.2、异步连接

异步连接采用非阻塞 io 实现，不会阻塞当前线程。缺点是代码书写异步，业务逻辑割裂，可以通过携程解决。在有大量并发请求的情况，配合 redis 6.0 以后的 io 多线程，异步连接池，能更好解决应用层的数据访问性能

5.2.1、redis 驱动

redis 驱动：服务端使用异步连接，需要自己来实现 redis 驱动，也就是说需要把 redis 连接融合自己项目中的 reactor 进行管理。

接着还需要设计 redis 适配器，其主要功能有：

构建 redis 事件对象，其中包括：hiredis 事件对象和 reactor 事件对象。
适配事件控制，复用项目中 reactor 的事件循环。

综上所述，hiredis 的封装规则有：

reactor 的实现：所有的 IO 由用户实现。
适配器的实现：hiredis 提供了事件操作接口，用户需要适配这些事件接口。

// 用户需要适配的 hiredis 事件接口有
addRead		// 添加读事件			
delRead 	// 删除读事件
addWrite	// 添加写事件
delWrite	// 删除写事件
cleanup		// 事件对象释放	
scheduleTimer

5.2.2、范例

这里对 4.1 的例子使用异步的方法来实现。

第 1 步，实现 redis 驱动

#ifndef _REACTOR_
#define _REACTOR_

#include <stdio.h>
#include <unistd.h> // read write
#include <fcntl.h> // fcntl
#include <sys/types.h> // listen
#include <sys/socket.h> // socket
#include <errno.h> // errno
#include <arpa/inet.h> // inet_addr htons
// #include <netinet/tcp.h>
#include <assert.h> // assert
#include <sys/epoll.h>
#include <stdlib.h> // malloc
#include <string.h> // memcpy memmove

#include "chainbuffer/buffer.h"
// #include "ringbuffer/buffer.h"

#define MAX_EVENT_NUM 512       // 每次用户拷贝事件的最大数目
#define MAX_CONN ((1<<16)-1)    // 事件对象的最大数目：65535

typedef struct event_s event_t;
typedef void (*event_callback_fn)(int fd, int events, void *privdata);
typedef void (*error_callback_fn)(int fd, char * err);

// reactor对象，管理 io 全局变量 
typedef struct {
    int epfd;        // epfd 
    int listenfd;    // 监听的fd
    int stop;        // 停止循环标记
    event_t *events; // 存储监听的所有事件(event_t)，存储在堆上，记得释放
    int iter;        // 用于遍历events，获取没有被使用的位置
    struct epoll_event fire[MAX_EVENT_NUM]; // 用户态数组，用于拷贝io事件到用户态
} reactor_t;

// 事件对象，sockitem，保存每个fd对应的io状态
struct event_s {
    int fd;         // 对应的事件 fd
    reactor_t *r;   // 指向 reactor 全局对象
    buffer_t in;    // 读缓冲，待读取
    buffer_t out;   // 写缓冲，待发送
    event_callback_fn read_fn;  // 读回调
    event_callback_fn write_fn; // 写回调
    error_callback_fn error_fn; // 错误回调
};

int event_buffer_read(event_t *e);
int event_buffer_write(event_t *e, void * buf, int sz);

// 创建 reactor 对象
reactor_t * create_reactor() {
    // 堆上申请 reactor 对象
    reactor_t *r = (reactor_t *)malloc(sizeof(*r));
    r->epfd = epoll_create(1);
    r->listenfd = 0;
    r->stop = 0;
    r->iter = 0;
    // 堆上申请 reactor 中的events数组
    r->events = (event_t*)malloc(sizeof(event_t)*MAX_CONN);
    memset(r->events, 0, sizeof(event_t)*MAX_CONN);
    memset(r->fire, 0, sizeof(struct epoll_event) * MAX_EVENT_NUM);
    // init_timer();
    return r;
}

// 释放 reactor 对象
void release_reactor(reactor_t * r) {
    free(r->events);    // 释放reactor在堆上申请的events
    close(r->epfd);     // 关闭epoll
    free(r);            // 释放reactor
}


// 从 reactor 的事件堆上获取空闲的事件对象
event_t * _get_event_t(reactor_t *r) {
    r->iter ++;
    // 寻找没有被使用的事件对象
    while (r->events[r->iter & MAX_CONN].fd > 0) {
        r->iter++;
    }
    return &r->events[r->iter];
}

// 基于事件的操作
// 1、创建事件对象
event_t * new_event(reactor_t *R, int fd,
    event_callback_fn rd,
    event_callback_fn wt,
    error_callback_fn err) {
    assert(rd != 0 || wt != 0 || err != 0);
    // 获取空闲的事件对象
    event_t *e = _get_event_t(R);
    
    // 初始化事件对象
    e->r = R;
    e->fd = fd;
    buffer_init(&e->in, 1024*16);
    buffer_init(&e->out, 1024*16);
    e->read_fn = rd;
    e->write_fn = wt;
    e->error_fn = err;

    return e;
}

// 2、添加事件
int add_event(reactor_t *R, int events, event_t *e) {
    struct epoll_event ev;
	ev.events = events;
	ev.data.ptr = e;

	if (epoll_ctl(R->epfd, EPOLL_CTL_ADD, e->fd, &ev) == -1) {
        printf("add event err fd = %d\n", e->fd);
		return 1;
	}
	return 0;
}

// 释放事件所占空间
void free_event(event_t *e) {
	buffer_free(&e->in);    
	buffer_free(&e->out);
}

// 3、删除事件
int del_event(reactor_t *R, event_t *e) {
	epoll_ctl(R->epfd, EPOLL_CTL_DEL, e->fd, NULL);
    free_event(e);
    return 0;
}

// 4、修改事件，由后面两个参数决定是读事件还是写事件
int enable_event(reactor_t *R, event_t *e, int readable, int writeable) {
	struct epoll_event ev;
	ev.events = (readable ? EPOLLIN : 0) | (writeable ? EPOLLOUT : 0);
	ev.data.ptr = e;

	if (epoll_ctl(R->epfd, EPOLL_CTL_MOD, e->fd, &ev) == -1) {
		return 1;
	}
	return 0;
}

// 一次事件循环
void eventloop_once(reactor_t * r, int timeout) {
    int n = epoll_wait(r->epfd, r->fire, MAX_EVENT_NUM, timeout);
    for (int i = 0; i < n; ++i) {
        struct epoll_event *e = &r->fire[i];  // 获取事件
        int mask = e->events;                 // 获取事件类型
        
        // 用 io 函数捕获具体的错误信息
        if (e->events & EPOLLERR) mask |= EPOLLIN | EPOLLOUT;
        // 用 io 函数捕获断开的具体信息
        if (e->events & EPOLLHUP) mask |= EPOLLIN | EPOLLOUT;
        
        event_t *et = (event_t*) e->data.ptr; // 获取事件关联的用户数据
        // 处理读事件
        if (mask & EPOLLIN) {
            if (et->read_fn) {
                et->read_fn(et->fd, EPOLLIN, et);   // 执行读回调
            }          
        }
        // 处理写事件
        if (mask & EPOLLOUT) {
            if (et->write_fn) {
                et->write_fn(et->fd, EPOLLOUT, et); // 执行写回调
            }     
            else {
                uint8_t *buf = buffer_write_atmost(&et->out);
                event_buffer_write(et, buf, buffer_len(&et->out));
            }
        }
    }
}

// 停止事件循环
void stop_eventloop(reactor_t * r) {
    r->stop = 1;
}

// 事件循环
void eventloop(reactor_t * r) {
    while (!r->stop) {
        // int timeout = find_nearest_expire_timer();
        eventloop_once(r, /*timeout*/ -1);
        // expire_timer();
    }
}

// 设置非阻塞fd
int set_nonblock(int fd) {
	int flag = fcntl(fd, F_GETFL, 0);
	return fcntl(fd, F_SETFL, flag | O_NONBLOCK);
}

// 创建服务器
int create_server(reactor_t *R, short port, event_callback_fn func) {
	// 1、socket
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
	if (listenfd < 0) {
        printf("create listenfd error!\n");
		return -1;
	}
	struct sockaddr_in addr;
	memset(&addr, 0, sizeof(struct sockaddr_in));
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = INADDR_ANY;

    // 设置地址可重用
    int reuse = 1;
	if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (void *)&reuse, sizeof(int)) == -1) {
        printf("reuse address error: %s\n", strerror(errno));
        return -1;
    }

    // 2、bind
	if (bind(listenfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0) {
        printf("bind error %s\n", strerror(errno));
		return -1;
	}

    // 3、listen
	if (listen(listenfd, 5) < 0) {
        printf("listen error %s\n", strerror(errno));
		return -1;
	}
    
    // 设置 listenfd 非阻塞 
    if (set_nonblock(listenfd) < 0) {
        printf("set_nonblock error %s\n", strerror(errno));
        return -1;
    }

    R->listenfd = listenfd;

    // 注册读事件
    event_t *e = new_event(R, listenfd, func, 0, 0);
    add_event(R, EPOLLIN, e);

	printf("listen port : %d\n", port);
	return 0;
}

// 读数据
int event_buffer_read(event_t *e) {
    int fd = e->fd; 
    int num = 0;    // 读取的数据总量
    while (1) {
        // TODO: dont use char buf[] here
        char buf[1024] = {0};
        int n = read(fd, buf, 1024);

        // 1、read=0, 服务器收到FIN包，半关闭状态
        // Todo: 半关闭状态逻辑处理，参考 skynet
        if (n == 0) { // 
            printf("close connection fd = %d\n", fd);
            if (e->error_fn) {
                e->error_fn(fd, "close socket");
            }   
            del_event(e->r, e);
            close(fd);
            return 0;
        } 
        // 2、read=-1，读异常
        else if (n < 0) {
            // 2.1、EINTR：中断，重试
            if (errno == EINTR) {
                continue;
            }
            // 2.2、EWOULDBLOCK：阻塞，读缓冲区为空 
            if (errno == EWOULDBLOCK) {
                break;
            }
            
            // 其他错误，执行错误回调，删除该事件，关闭当前连接
            printf("read error fd = %d err = %s\n", fd, strerror(errno));
            if (e->error_fn)
                e->error_fn(fd, strerror(errno));
            del_event(e->r, e);
            close(fd);
            return 0;
        } 
        // 3、read>0, 正常，读取数据，处理业务逻辑
        else {
            printf("recv data from client:%s", buf);
            buffer_add(&e->in, buf, n);
        }
        num += n;
    }
    return num;
}

// 向对端发送数据
int _write_socket(event_t *e, void * buf, int sz) {
    int fd = e->fd;
    while (1) {
        int n = write(fd, buf, sz);
        // 1、write=-1，写异常
        if (n < 0) {
            // 2.1、EINTR：中断，重试
            if (errno == EINTR) {
                continue;
            }  
            // 2.2、EWOULDBLOCK：阻塞，需要注册写事件
            if (errno == EWOULDBLOCK) {
                break;
            }
            // 其他错误，执行错误回调，删除该事件，关闭当前连接   
            if (e->error_fn) {
                e->error_fn(fd, strerror(errno));
            }     
            del_event(e->r, e);
            close(e->fd);
        }
        return n;
    }
    return 0;
}

// 写数据
int event_buffer_write(event_t *e, void * buf, int sz) {
    // 指向用户写缓冲
    buffer_t *r = &e->out;
    // 1、用户写缓冲已满，开始发送
    if (buffer_len(r) == 0) {
        // 向对端发送数据
        int n = _write_socket(e, buf, sz);
        // 1.1、本次数据未发送完，未发送的数据写入缓冲，并注册写事件
        if (n == 0 || n < sz) {
            // 1.1、将没有发送完的数据写入缓冲区
            buffer_add(&e->out, (char *)buf + n, sz - n);
            // 1.2、注册写事件，等待下次事件触发接着发送
            enable_event(e->r, e, 1, 1);
            return 0;
        } 
        // 1.2、本次没有发送数据
        else if (n < 0) {
            return 0;
        }
        // 1.3、本次数据发送完成    
        return 1;
    }
    // 2、用户写缓冲未满，写入缓冲，等待发送
    buffer_add(&e->out, (char *)buf, sz);
    return 1;
}

#endif

第 2 步，实现 redis 适配器，主要是构建 redis 事件对象和适配 hiredis 的事件控制接口。

// adapter_async.h
#ifndef _MARK_ADAPTER_
#define _MARK_ADAPTER_

#include <hiredis/hiredis.h>
#include <hiredis/alloc.h>
#include "reactor.h"

// redis 事件对象
typedef struct {
    event_t e;              // reactor 事件对象
    int mask;               // 存储注册的事件
    redisAsyncContext *ctx; // hiredis 事件对象
} redis_event_t;

// redis 对象读事件回调
static void redisReadHandler(int fd, int events, void *privdata) {
    ((void)fd);
    ((void)events);
    event_t *e = (event_t*)privdata;
    redis_event_t *re = (redis_event_t *)(char *)e;
    redisAsyncHandleRead(re->ctx);
}

// redis 对象写事件读回调
static void redisWriteHandler(int fd, int events, void *privdata) {
    ((void)fd);
    ((void)events);
    event_t *e = (event_t*)privdata;
    redis_event_t *re = (redis_event_t *)(char *)e;
    redisAsyncHandleWrite(re->ctx);
}

/**
 * @brief 对 reactor 管理的事件对象进行更新
 * @param privdata  redis 事件对象
 * @param flag      要设置的 epoll 事件类型 
 * @param remove    1 删除该事件 0 添加该事件
 */
static void redisEventUpdate(void *privdata, int flag, int remove) {
    redis_event_t *re = (redis_event_t *)privdata;
    reactor_t *r = re->e.r;
    int prevMask = re->mask;
    int enable = 0;             
    // redis 事件对象删除该事件
    if (remove) {
        if ((re->mask & flag) == 0) {
            return;
        }
        re->mask &= ~flag;
        enable = 0;
    } 
    // redis 事件对象添加该事件
    else {
        if (re->mask & flag) {
            return;    
        }           
        re->mask |= flag;
        enable = 1;
    }
    
    // 对 reactor 事件对象的处理
    // 1、reactor 事件对象删除该事件
    if (re->mask == 0) {
        del_event(r, &re->e);
    } 
    // 2、reactor 事件对象添加该事件（第一次加入）
    else if (prevMask == 0) {
        add_event(r, re->mask, &re->e);
    } 
    // 3、reactor 事件对象修改该事件
    else {
        // 注册读事件
        if (flag & EPOLLIN) {
            enable_event(r, &re->e, enable, 0);
        } 
        // 注册写事件
        else if (flag & EPOLLOUT) {
            enable_event(r, &re->e, 0, enable);
        }
    }
}

// 需要适配的 hiredis 事件接口
// 1、redis 事件对象添加读事件
static void redisAddRead(void *privdata) {
    redis_event_t *re = (redis_event_t *)privdata;
    re->e.read_fn = redisReadHandler;
    redisEventUpdate(privdata, EPOLLIN, 0);
}

// 2、redis 事件对象删除读事件
static void redisDelRead(void *privdata) {
    redis_event_t *re = (redis_event_t *)privdata;
    re->e.read_fn = 0;
    redisEventUpdate(privdata, EPOLLIN, 1);
}

// 3、redis 事件对象添加写事件
static void redisAddWrite(void *privdata) {
    redis_event_t *re = (redis_event_t *)privdata;
    re->e.write_fn = redisWriteHandler;
    redisEventUpdate(privdata, EPOLLOUT, 0);
}

// 4、redis 事件对象删除写事件
static void redisDelWrite(void *privdata) {
    redis_event_t *re = (redis_event_t *)privdata;
    re->e.write_fn = 0;
    redisEventUpdate(privdata, EPOLLOUT, 1);
}

// 5、redis 事件对象释放
static void redisCleanup(void *privdata) {
    redis_event_t *re = (redis_event_t *)privdata;
    reactor_t *r = re->e.r;
    del_event(r, &re->e);
    hi_free(re);
}

// redis 事件对象绑定，reactor 对象和 redis 异步上下文
static int redisAttach(reactor_t *r, redisAsyncContext *ac) { 
    redisContext *c = &(ac->c); // redis 同步上下文
    redis_event_t *re;          // redis 事件对象
    
    /* Nothing should be attached when something is already attached */
    if (ac->ev.data != NULL)
        return REDIS_ERR;

    /* Create container for ctx and r/w events */
    re = (redis_event_t*)hi_malloc(sizeof(*re));
    if (re == NULL) {
        return REDIS_ERR;
    }  

    // redis 事件对象绑定 reactor 对象和 redis 异步上下文
    re->ctx = ac;       // 绑定 redis 异步上下文
    re->e.fd = c->fd;   // 绑定 redis 的fd
    re->e.r = r;        // 绑定 reacotr
    re->mask = 0;       // 绑定事件

    // redis 异步上下文设置，需要适配事件控制
    // hiredis 提供事件接口，用户实现事件接口
    ac->ev.addRead = redisAddRead;
    ac->ev.delRead = redisDelRead;
    ac->ev.addWrite = redisAddWrite;
    ac->ev.delWrite = redisDelWrite;
    ac->ev.cleanup = redisCleanup;
    ac->ev.data = re;

    return REDIS_OK;
}

#endif

接下来，实现主体代码，实现功能

// redis-test-async.c
// gcc redis-test-async.c chainbuffer/buffer.c -o async -lhiredis
#include <hiredis/hiredis.h>
#include <hiredis/async.h>
#include <time.h>

#include "reactor.h"
#include "adapter_async.h"

static reactor_t *R;
static int cnt, before, num;

int current_tick() {
    int t = 0;
    struct timespec ti;
	clock_gettime(CLOCK_MONOTONIC, &ti);
	t = (int)ti.tv_sec * 1000;
	t += ti.tv_nsec / 1000000;
    return t;
}

void getCallback(redisAsyncContext *c, void *r, void *privdata) {
    redisReply *reply = r;
    if (reply == NULL) return;
    printf("argv[%s]: %lld\n", (char*)privdata, reply->integer);

    /* Disconnect after receiving the reply to GET */
    cnt++;
    if (cnt == num) {
        int used = current_tick()-before;
        printf("after %d exec redis command, used %d ms\n", num, used);
        redisAsyncDisconnect(c);
    }
}


void connectCallback(const redisAsyncContext *c, int status) {
    if (status != REDIS_OK) {
        printf("Error: %s\n", c->errstr);
        stop_eventloop(R);
        return;
    }
    printf("Connected...\n");
}

void disconnectCallback(const redisAsyncContext *c, int status) {
    if (status != REDIS_OK) {
        printf("Error: %s\n", c->errstr);
        stop_eventloop(R);
        return;
    }

    printf("Disconnected...\n");
    stop_eventloop(R);
}

int main(int argc, char **argv) {
    redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
    if (c->err) {
        /* Let *c leak for now... */
        printf("Error: %s\n", c->errstr);
        return 1;
    }
    
    R = create_reactor();
    redisAttach(R, c);   
    redisAsyncSetConnectCallback(c, connectCallback);
    redisAsyncSetDisconnectCallback(c, disconnectCallback);

    before = current_tick();
    num = (argc > 1) ? atoi(argv[1]) : 1000;

    redisAsyncCommand(c, NULL, NULL, "auth 123456");  
    for (int i = 0; i < num; i++) {
        redisAsyncCommand(c, getCallback, "count", "INCR counter");
    }
    
    eventloop(R);

    release_reactor(R);
    return 0;
}