一、redis pipeline
首先我们需要知道从客户端发送一条命令到redis中执行的过程中经历了什么:发送命令->命令排队->命令执行->返回结果。这个过程称为Round trip time(简称RTT,往返时间),如果当我们发送N条命令,那么需要消耗N次RTT,效率比较低下。
这时候我们采用一种叫pipeline来解决这样的问题。通过将多个命令一起发送,然后接收多次结果,这样就可以大大提高效率。这样的方式和异步IO很像。
首先redis pipeline是一个客户端提供的机制,而不是服务端提供的机制。其次对于原生批命令(mset,mget)这些都是原子性操作,但是pipeline是非原子性的。
原子性概念:一个事务是一个不可分割的最小工作单位,要么都成功,要么都失败。因此对于pipeline来说既然它不是原子性的,那么它也就不具备事务性。
因此pipeline只是将多条命令放在一起发送,这样只是为了减少网络传输的时间。原生批命令是服务端实现的,但是pipeline需要服务端和客户端共同完成。
二、redis事务
redis事务是一组命令的集合,允许用户在一个单独的操作序列中执行多个命令,并保证这些命令在执行过程中不会被其他客户端的命令打断。redis事务通过MULTI,EXEC,DISCARD和WATCH等命令来实现。
1、redis事务的基本操作
开启事务:使用MULTI命令标记一个事务的开始。在MULTI命令之后,客户端发送的命令会被Redis服务器接收并放入到一个事务队列中,但不会立即执行。
命令入队:在MULTI和EXEC之间发送的命令都会被加入到事务队列中。这些命令会按照发送的顺序被序列化,并在
EXEC
命令执行时按顺序执行。执行事务:使用EXEC命令执行事务队列中的所有命令。Redis会按照命令入队的顺序执行这些命令,并将所有命令的返回值作为EXEC命令的返回值返回给客户端。
取消事务:如果在事务执行之前需要取消事务,可以使用DISCARD命令。这将清空事务队列,并放弃执行事务块中的所有命令。
下面这个是通过事务进行整体操作:
这个是在运行事务的过程中,中途退出事务,则不会改变其中的变量。
2、乐观锁实现
Redis提供了WATCH命令来实现乐观锁机制。使用WATCH命令可以监视一个或多个键,如果在事务执行之前这些键被其他命令修改了,那么事务将被取消执行。这可以帮助避免在并发环境下出现数据不一致的问题。
通过使用WATCH来观察一个Key值,当这个值被修改的时候那么关于这个值的事务将被取消。下面第一张图我是使用第一个客户端进行观察并且使用事务,第二张图是第二个客户端修改num的值,第三张图就是第二个客户端修改之后,第一张图的变化,发现我们事务的操作失败了。
三、Lua脚本实现原子性
Lua 是一种轻量级的、可扩展的编程语言,设计用来嵌入应用程序中,以提供灵活的脚本功能。在多种环境下,Lua 被用作脚本语言,特别是在游戏开发(如 Unity、Roblox)、网络应用、嵌入式系统等领域。在 Redis、Nginx 等一些系统或应用中,Lua 脚本可以被用来执行复杂的操作,这些操作可能涉及到多次对数据库的访问或复杂的逻辑处理。
redis 中加载了一个 lua 虚拟机;用来执行 redis lua 脚本;redis lua 脚本的执行是原子性的;当某个脚本正在执行的时候,不会有其他命令或者脚本被执行;
lua 脚本当中的命令会直接修改数据状态;
lua 脚本 mysql 存储区别:MySQL存储过程不具备事务性,所以也不具备原子性;
注意:如果项目中使用了 lua 脚本,不需要使用上面的事务命令;
接下来我们使用lua脚本来实现执行相关命令,其中使用了EVAL和EVALSHA。我们通过EVAL来实现数据的翻倍。
EVAL script numkeys key [key ...] arg [arg ...]
//script是要执行的Lua脚本
//numkeys是后续参数中key的数量,用来区分哪些参数是键名,哪些是普通的参数
//key传入的键名
//arg传入的参数
EVALSHA sha1 numkeys key [key ...] arg [arg ...]
//sha1是哈希值
1、EVAL实现数据翻倍
eval 'local key = KEYS[1]; local val = redis.call("get",key); redis.call("set",key,2*val);return 2*val ' 1 num
//在''这个之中的代码就是lua脚本
//我们先看后面的参数: 1 num ,这告诉lua脚本有一个key,这个key叫num
//那么我们通过local key = KEYS[1]; 获得第一个key:num
//通过local val = redis.call("get",key); get num ,这个来获得num的值,假如这里val是4
//redis.call("set",key,2*val); set num 8 ,这个8就是二倍的4,那么我们就实现了翻倍
//最后return 2*val; 告诉我们最后翻倍的值是多少。
2、EVALSHA实现数据翻倍
虽然我们这样写之后很方便,直接复制我们写好之后的lua脚本就可以,但是我们这只是个很小的测试案例,在项目中这段lua脚本会很长,这样的话就不会很方便了。那么我们将这段代码通过哈希一下,得到一个哈希值,我们使用这个哈希值来代替这段lua脚本,岂不是很方便。于是我们就可以使用这个EVALSHA了。
我们通过使用 script load 来将我们的lua脚本进行生成哈希值,这个哈希值就代表我们的lua脚本。我们可以通过 script exists 来查看某个哈希值是否存在。然后我们就可以使用这个哈希值了。
# 清除所有脚本缓存
> script flush
# 如果当前脚本运行时间过长(死循环),可以通过 script kill 杀死当前运行的脚本
> script kill
四、发布订阅
为了支持消息的多播机制,redis 引入了发布订阅模块; 消息不一定可达;分布式消息队列; stream 的方式确保一定可达;
# 订阅频道
subscribe 频道
# 订阅模式频道
psubscribe 频道
# 取消订阅频道
unsubscribe 频道
# 取消订阅模式频道
punsubscribe 频道
# 发布具体频道或模式频道的内容
publish 频道 内容
# 客户端收到具体频道内容
message 具体频道 内容
# 客户端收到模式频道内容
pmessage 模式频道 具体频道 内容
发布订阅功能一般要区别命令连接重新开启一个连接;因为命令连接严格遵循请求回应模式;而 pubsub 能收到 redis 主动推送的内容;所以实际项目中如果支持 pubsub 的话,需要另开一条连接 用于处理发布订阅;
发布订阅的生产者传递过来一个消息,redis 会直接找到相应的消费者并传递过去;假如没有消费者,消息直接丢弃;假如开始有2个消费者,一个消费者突然挂掉了,另外一个消费者依然能收到 消息,但是如果刚挂掉的消费者重新连上后,在断开连接期间的消息对于该消费者来说彻底丢失 了; 另外,redis 停机重启,pubsub 的消息是不会持久化的,所有的消息被直接丢弃;
subscribe news.it news.showbiz news.car
psubscribe news.*
publish new.showbiz 'king kiss darren'
lua脚本和订阅的具体应用:当项目启动时,建立redis连接并验证后,先加载所有项目中使用的lua脚本(script load);项目中若需要热更新,通过redis-cli script flush;然后可以通过订阅发布功能通知所有服务器,重新加载lua脚本;若项目中lua脚本发生阻塞,可通过script kill暂停当前阻塞脚本的执行;
五、ACID特性分析
A 原子性:事务是一个不可分割的工作单位,事务中的操作要么全部成功,要么全部失败;redis 不支持回滚;即使事务队列中的某个命令在执行期间出现了错误,整个事务也会继续执行下去,直到将事务队列中的所有命令都执行完毕为止。
C 一致性:事务的前后,所有的数据都保持一个一致的状态,不能违反数据的一致性检测;这里的一致性是指预期的一致性而不是异常后的一致性;所以 redis 也不满足;这个争议很大:redis 能确保事务执行前后的数据的完整约束;但是并不满足业务功能上的一致性;比如转账功能,一个扣钱一个加钱;可能出现扣钱执行错误,加钱执行正确,那么最终还是会加钱成功;系统凭空多了钱;
I 隔离性:各个事务之间互相影响的程度;redis 是单线程执行,天然具备隔离性;
D 持久性:redis 只有在 aof 持久化策略的时候,并且需要在 redis.conf 中 appendfsync=always 才具备持久性;实际项目中几乎不会使用 aof 持久化策略;
AOF(Append Only File)持久化策略是Redis数据库用于保证数据持久性的重要机制之一。AOF持久化通过记录Redis服务器所接收的写命令来保存数据库状态,当Redis重启时,它会重新执行AOF文件中的命令来恢复数据。
那么我们可以发现 lua 脚本满足原子性和隔离性;一致性和持久性不满足;
六、redis的同步连接
首先我们如果需要与redis进行连接的话,需要用到hiredis库通过使用这个hiredis库就可以与redis进行通信了。下面我们可以看一个同步连接的例子。
redisContext *c; //redis的上下文,也就是与redis连接的实体
redisReply *reply; //redis的回复
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 roleid = 10001;
reply = redisCommand(c, "hgetall role:%d", roleid); //调用执行的命令,这里我们固定查询 role:10001 这个key值
if (reply->type != REDIS_REPLY_ARRAY) {
printf("reply error: %s\n", reply->str);
} else {
printf("reply:number of elements=%lu\n", reply->elements);
for (size_t i = 0; i < reply->elements; i++) {
printf("\t %lu : %s\n", i, reply->element[i]->str);
}
}
七、redis的异步连接
同步连接方案采用阻塞 io 来实现;优点是代码书写是同步的,业务逻辑没有割裂;缺点是阻塞当前线程,直至 redis 返回结果;通常用多个线程来实现线程池来解决效率问题;
异步连接方案采用非阻塞 io 来实现;优点是没有阻塞当前线程,redis 没有返回,依然可以往 redis 发送命令;缺点是代码书写是异步的(回调函数),业务逻辑割裂,可以通过协程解决 (openresty,skynet);配合 redis6.0 以后的 io 多线程(前提是有大量并发请求),异步连接池,能更好解决应用层的数据访问性能;
首先redis提供了同步和异步不同的对象,并且对于异步的结构体来说,正好可以适配我们的reactor模型的回调函数。
//同步
redisContext *c = redisConnectWithTimeout("127.0.0.1", 6379, timeout);
//异步
redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
//因此我们使用的时候一定要区分。
1、redis_event_t 的结构
struct event_s {
int fd;
reactor_t *r;
buffer_t *in; //读缓冲区
buffer_t *out; //写缓冲区
event_callback_fn read_fn; //一些回调函数
event_callback_fn write_fn;
error_callback_fn error_fn;
}event_t;
typedef struct {
event_t e; //事件
int mask; //事件触发的类型
redisAsyncContext *ctx; //异步redis的上下文
} redis_event_t;
typedef struct redisAsyncContext {
redisContext c; //同步redis的上下文
int err;
char *errstr;
void *data;
void (*dataCleanup)(void *privdata);
struct {
void *data;
void (*addRead)(void *privdata);
void (*delRead)(void *privdata);
void (*addWrite)(void *privdata);
void (*delWrite)(void *privdata);
void (*cleanup)(void *privdata);
void (*scheduleTimer)(void *privdata, struct timeval tv);
} ev;
redisDisconnectCallback *onDisconnect;
redisConnectCallback *onConnect;
redisCallbackList replies;
struct sockaddr *saddr;
size_t addrlen;
struct {
redisCallbackList invalid;
struct dict *channels;
struct dict *patterns;
} sub;
redisAsyncPushFn *push_cb;
} redisAsyncContext;
我们发现这个 redis_event_t 中所包含event_t、异步redisAsyncContext ,而在异步 redisAsyncContext 中却包含着同步 redisContext 。因此我们可以画一下这个图。这样我们可以清楚的知道,在异步上下文中包含着读写事件的注册和删除,在同步上下文中包含着自己的fd,在event_t中包含着传入进来的reactor和一系列的回调函数将这全部的东西全部放入到redis_event_t中去。(如果想知道具体的同步异步上下文都包含什么,可以自己去下载hiredis代码去查看)。
2、redisAttach
我们在这个函数中将这个异步上下文和这个reactor绑在一起。其中设置各种参数,也就是说将他们这一群都互相认定一样。
static int redisAttach(reactor_t *r, redisAsyncContext *ac) {
redisContext *c = &(ac->c); //上面那个是异步的上下文,这个是同步的上下文,异步的上下文中含有回调函数,同步中含有fd
redis_event_t *re; //这个event中含有自己写的事件(回调函数)和异步的上下文,也就是说这个包含上面的异步上下文。
/* 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;
re->ctx = ac; //再这个re中携带上这个异步的上下文。
re->e.fd = c->fd; //再携带上同步上下文的fd
re->e.r = r; //再包含上咱们传入的reactor
//由于咱们自己写的事件类型中包含读写缓冲区,但是我们需要使用hiredis中的读写缓冲区
// dont use event buffer, using hiredis's buffer
re->e.in = NULL;
re->e.out = NULL;
re->mask = 0; //现在的事件为0
//为这个异步中的回调函数设置上咱们自己的回调函数。
ac->ev.addRead = redisAddRead; //添加读事件
ac->ev.delRead = redisDelRead;
ac->ev.addWrite = redisAddWrite;
ac->ev.delWrite = redisDelWrite;
ac->ev.cleanup = redisCleanup;
ac->ev.data = re; //我们将这个redis_event_t和这个异步上下文互相指向
return REDIS_OK;
}
3、redisAddRead
这些回调函数太多了,我们只拿出一个举例。当我们看到 redisEventUpdate 函数的时候,发现里面写的都是关于 epoll 中的event的事件,因此可以发现我们写的reactor和这个异步hiredis非常适配。
//添加读事件
static void redisAddRead(void *privdata) {
redis_event_t *re = (redis_event_t *)privdata; //将这个参数强转成这个事件类型
re->e.read_fn = redisReadHandler; //设置这个读事件的回调函数
redisEventUpdate(privdata, EPOLLIN, 0);
}
//设置读事件的处理函数(这里是回调函数)
static void redisReadHandler(int fd, int events, void *privdata) {
((void)fd);
((void)events);
printf("redisReadHandler %d\n", fd);
event_t *e = (event_t*)privdata;
redis_event_t *re = (redis_event_t *)(char *)e; //将这个小的event包含在这个redis_event中了
redisAsyncHandleRead(re->ctx); //调用库函数,将这个异步的上下文传入进去
}
//更新它的事件状态
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;
if (remove) {
if ((re->mask & flag) == 0)
return ;
re->mask &= ~flag;
enable = 0;
} else {
if (re->mask & flag)
return ;
re->mask |= flag;
enable = 1;
}
int fd = re->ctx->c.fd;
if (re->mask == 0) {
del_event(r, &re->e);
} else if (prevMask == 0) {
add_event(r, re->mask, &re->e);
} else {
if (flag & EPOLLIN) {
enable_event(r, &re->e, enable, 0);
} else if (flag & EPOLLOUT) {
enable_event(r, &re->e, 0, enable);
}
}
}
4、运行的具体函数
我们通过这个函数对redis进行具体的执行操作。比如下面的查看所有的role:10001的value。
void
connectCallback(const redisAsyncContext *c, int status) {
if (status != REDIS_OK) {
printf("Error: %s\n", c->errstr);
stop_eventloop(R);
return;
}
printf("Connected...\n");
redisAsyncCommand((redisAsyncContext *)c, dumpReply,
"hmset role:10001",
"hmset role:10001 name mark age 31 sex male");
int a = 10;
redisAsyncCommand((redisAsyncContext *)c, dumpReply, "hgetall role:10001", "hgetall role:10001");
// ....
}
5、整个过程
int main(int argc, char **argv) {
R = create_reactor();
redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379); //进行连接操作
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
return 1;
}
redisAttach(R, c); //将这俩参数传入进去进行绑定,设置一些回调函数
redisAsyncSetConnectCallback(c, connectCallback); //连接上的回调函数,连接后第一时间执行的
redisAsyncSetDisconnectCallback(c, disconnectCallback);
eventloop(R); //将这个程序运行起来
release_reactor(R);
return 0;
}
感谢大家的观看!0voice · GitHub