漫话Redis源码之三十六

2024-02-06 09:48
文章标签 源码 redis 三十六 漫话

本文主要是介绍漫话Redis源码之三十六，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

这里主要是Pubsub相关的API, 大致看看就行，知道他的功能就基本差不多了：

#include "server.h"int clientSubscriptionsCount(client *c);/*-----------------------------------------------------------------------------* Pubsub client replies API*----------------------------------------------------------------------------*//* Send a pubsub message of type "message" to the client.* Normally 'msg' is a Redis object containing the string to send as* message. However if the caller sets 'msg' as NULL, it will be able* to send a special message (for instance an Array type) by using the* addReply*() API family. */
void addReplyPubsubMessage(client *c, robj *channel, robj *msg) {if (c->resp == 2)addReply(c,shared.mbulkhdr[3]);elseaddReplyPushLen(c,3);addReply(c,shared.messagebulk);addReplyBulk(c,channel);if (msg) addReplyBulk(c,msg);
}/* Send a pubsub message of type "pmessage" to the client. The difference* with the "message" type delivered by addReplyPubsubMessage() is that* this message format also includes the pattern that matched the message. */
void addReplyPubsubPatMessage(client *c, robj *pat, robj *channel, robj *msg) {if (c->resp == 2)addReply(c,shared.mbulkhdr[4]);elseaddReplyPushLen(c,4);addReply(c,shared.pmessagebulk);addReplyBulk(c,pat);addReplyBulk(c,channel);addReplyBulk(c,msg);
}/* Send the pubsub subscription notification to the client. */
void addReplyPubsubSubscribed(client *c, robj *channel) {if (c->resp == 2)addReply(c,shared.mbulkhdr[3]);elseaddReplyPushLen(c,3);addReply(c,shared.subscribebulk);addReplyBulk(c,channel);addReplyLongLong(c,clientSubscriptionsCount(c));
}/* Send the pubsub unsubscription notification to the client.* Channel can be NULL: this is useful when the client sends a mass* unsubscribe command but there are no channels to unsubscribe from: we* still send a notification. */
void addReplyPubsubUnsubscribed(client *c, robj *channel) {if (c->resp == 2)addReply(c,shared.mbulkhdr[3]);elseaddReplyPushLen(c,3);addReply(c,shared.unsubscribebulk);if (channel)addReplyBulk(c,channel);elseaddReplyNull(c);addReplyLongLong(c,clientSubscriptionsCount(c));
}/* Send the pubsub pattern subscription notification to the client. */
void addReplyPubsubPatSubscribed(client *c, robj *pattern) {if (c->resp == 2)addReply(c,shared.mbulkhdr[3]);elseaddReplyPushLen(c,3);addReply(c,shared.psubscribebulk);addReplyBulk(c,pattern);addReplyLongLong(c,clientSubscriptionsCount(c));
}/* Send the pubsub pattern unsubscription notification to the client.* Pattern can be NULL: this is useful when the client sends a mass* punsubscribe command but there are no pattern to unsubscribe from: we* still send a notification. */
void addReplyPubsubPatUnsubscribed(client *c, robj *pattern) {if (c->resp == 2)addReply(c,shared.mbulkhdr[3]);elseaddReplyPushLen(c,3);addReply(c,shared.punsubscribebulk);if (pattern)addReplyBulk(c,pattern);elseaddReplyNull(c);addReplyLongLong(c,clientSubscriptionsCount(c));
}/*-----------------------------------------------------------------------------* Pubsub low level API*----------------------------------------------------------------------------*//* Return the number of channels + patterns a client is subscribed to. */
int clientSubscriptionsCount(client *c) {return dictSize(c->pubsub_channels)+listLength(c->pubsub_patterns);
}/* Subscribe a client to a channel. Returns 1 if the operation succeeded, or* 0 if the client was already subscribed to that channel. */
int pubsubSubscribeChannel(client *c, robj *channel) {dictEntry *de;list *clients = NULL;int retval = 0;/* Add the channel to the client -> channels hash table */if (dictAdd(c->pubsub_channels,channel,NULL) == DICT_OK) {retval = 1;incrRefCount(channel);/* Add the client to the channel -> list of clients hash table */de = dictFind(server.pubsub_channels,channel);if (de == NULL) {clients = listCreate();dictAdd(server.pubsub_channels,channel,clients);incrRefCount(channel);} else {clients = dictGetVal(de);}listAddNodeTail(clients,c);}/* Notify the client */addReplyPubsubSubscribed(c,channel);return retval;
}/* Unsubscribe a client from a channel. Returns 1 if the operation succeeded, or* 0 if the client was not subscribed to the specified channel. */
int pubsubUnsubscribeChannel(client *c, robj *channel, int notify) {dictEntry *de;list *clients;listNode *ln;int retval = 0;/* Remove the channel from the client -> channels hash table */incrRefCount(channel); /* channel may be just a pointer to the same objectwe have in the hash tables. Protect it... */if (dictDelete(c->pubsub_channels,channel) == DICT_OK) {retval = 1;/* Remove the client from the channel -> clients list hash table */de = dictFind(server.pubsub_channels,channel);serverAssertWithInfo(c,NULL,de != NULL);clients = dictGetVal(de);ln = listSearchKey(clients,c);serverAssertWithInfo(c,NULL,ln != NULL);listDelNode(clients,ln);if (listLength(clients) == 0) {/* Free the list and associated hash entry at all if this was* the latest client, so that it will be possible to abuse* Redis PUBSUB creating millions of channels. */dictDelete(server.pubsub_channels,channel);}}/* Notify the client */if (notify) addReplyPubsubUnsubscribed(c,channel);decrRefCount(channel); /* it is finally safe to release it */return retval;
}/* Subscribe a client to a pattern. Returns 1 if the operation succeeded, or 0 if the client was already subscribed to that pattern. */
int pubsubSubscribePattern(client *c, robj *pattern) {dictEntry *de;list *clients;int retval = 0;if (listSearchKey(c->pubsub_patterns,pattern) == NULL) {retval = 1;listAddNodeTail(c->pubsub_patterns,pattern);incrRefCount(pattern);/* Add the client to the pattern -> list of clients hash table */de = dictFind(server.pubsub_patterns,pattern);if (de == NULL) {clients = listCreate();dictAdd(server.pubsub_patterns,pattern,clients);incrRefCount(pattern);} else {clients = dictGetVal(de);}listAddNodeTail(clients,c);}/* Notify the client */addReplyPubsubPatSubscribed(c,pattern);return retval;
}/* Unsubscribe a client from a channel. Returns 1 if the operation succeeded, or* 0 if the client was not subscribed to the specified channel. */
int pubsubUnsubscribePattern(client *c, robj *pattern, int notify) {dictEntry *de;list *clients;listNode *ln;int retval = 0;incrRefCount(pattern); /* Protect the object. May be the same we remove */if ((ln = listSearchKey(c->pubsub_patterns,pattern)) != NULL) {retval = 1;listDelNode(c->pubsub_patterns,ln);/* Remove the client from the pattern -> clients list hash table */de = dictFind(server.pubsub_patterns,pattern);serverAssertWithInfo(c,NULL,de != NULL);clients = dictGetVal(de);ln = listSearchKey(clients,c);serverAssertWithInfo(c,NULL,ln != NULL);listDelNode(clients,ln);if (listLength(clients) == 0) {/* Free the list and associated hash entry at all if this was* the latest client. */dictDelete(server.pubsub_patterns,pattern);}}/* Notify the client */if (notify) addReplyPubsubPatUnsubscribed(c,pattern);decrRefCount(pattern);return retval;
}/* Unsubscribe from all the channels. Return the number of channels the* client was subscribed to. */
int pubsubUnsubscribeAllChannels(client *c, int notify) {int count = 0;if (dictSize(c->pubsub_channels) > 0) {dictIterator *di = dictGetSafeIterator(c->pubsub_channels);dictEntry *de;while((de = dictNext(di)) != NULL) {robj *channel = dictGetKey(de);count += pubsubUnsubscribeChannel(c,channel,notify);}dictReleaseIterator(di);}/* We were subscribed to nothing? Still reply to the client. */if (notify && count == 0) addReplyPubsubUnsubscribed(c,NULL);return count;
}/* Unsubscribe from all the patterns. Return the number of patterns the* client was subscribed from. */
int pubsubUnsubscribeAllPatterns(client *c, int notify) {listNode *ln;listIter li;int count = 0;listRewind(c->pubsub_patterns,&li);while ((ln = listNext(&li)) != NULL) {robj *pattern = ln->value;count += pubsubUnsubscribePattern(c,pattern,notify);}if (notify && count == 0) addReplyPubsubPatUnsubscribed(c,NULL);return count;
}/* Publish a message */
int pubsubPublishMessage(robj *channel, robj *message) {int receivers = 0;dictEntry *de;dictIterator *di;listNode *ln;listIter li;/* Send to clients listening for that channel */de = dictFind(server.pubsub_channels,channel);if (de) {list *list = dictGetVal(de);listNode *ln;listIter li;listRewind(list,&li);while ((ln = listNext(&li)) != NULL) {client *c = ln->value;addReplyPubsubMessage(c,channel,message);receivers++;}}/* Send to clients listening to matching channels */di = dictGetIterator(server.pubsub_patterns);if (di) {channel = getDecodedObject(channel);while((de = dictNext(di)) != NULL) {robj *pattern = dictGetKey(de);list *clients = dictGetVal(de);if (!stringmatchlen((char*)pattern->ptr,sdslen(pattern->ptr),(char*)channel->ptr,sdslen(channel->ptr),0)) continue;listRewind(clients,&li);while ((ln = listNext(&li)) != NULL) {client *c = listNodeValue(ln);addReplyPubsubPatMessage(c,pattern,channel,message);receivers++;}}decrRefCount(channel);dictReleaseIterator(di);}return receivers;
}/*-----------------------------------------------------------------------------* Pubsub commands implementation*----------------------------------------------------------------------------*//* SUBSCRIBE channel [channel ...] */
void subscribeCommand(client *c) {int j;if ((c->flags & CLIENT_DENY_BLOCKING) && !(c->flags & CLIENT_MULTI)) {/*** A client that has CLIENT_DENY_BLOCKING flag on* expect a reply per command and so can not execute subscribe.** Notice that we have a special treatment for multi because of* backword compatibility*/addReplyError(c, "SUBSCRIBE isn't allowed for a DENY BLOCKING client");return;}for (j = 1; j < c->argc; j++)pubsubSubscribeChannel(c,c->argv[j]);c->flags |= CLIENT_PUBSUB;
}/* UNSUBSCRIBE [channel [channel ...]] */
void unsubscribeCommand(client *c) {if (c->argc == 1) {pubsubUnsubscribeAllChannels(c,1);} else {int j;for (j = 1; j < c->argc; j++)pubsubUnsubscribeChannel(c,c->argv[j],1);}if (clientSubscriptionsCount(c) == 0) c->flags &= ~CLIENT_PUBSUB;
}/* PSUBSCRIBE pattern [pattern ...] */
void psubscribeCommand(client *c) {int j;if ((c->flags & CLIENT_DENY_BLOCKING) && !(c->flags & CLIENT_MULTI)) {/*** A client that has CLIENT_DENY_BLOCKING flag on* expect a reply per command and so can not execute subscribe.** Notice that we have a special treatment for multi because of* backword compatibility*/addReplyError(c, "PSUBSCRIBE isn't allowed for a DENY BLOCKING client");return;}for (j = 1; j < c->argc; j++)pubsubSubscribePattern(c,c->argv[j]);c->flags |= CLIENT_PUBSUB;
}/* PUNSUBSCRIBE [pattern [pattern ...]] */
void punsubscribeCommand(client *c) {if (c->argc == 1) {pubsubUnsubscribeAllPatterns(c,1);} else {int j;for (j = 1; j < c->argc; j++)pubsubUnsubscribePattern(c,c->argv[j],1);}if (clientSubscriptionsCount(c) == 0) c->flags &= ~CLIENT_PUBSUB;
}/* PUBLISH <channel> <message> */
void publishCommand(client *c) {int receivers = pubsubPublishMessage(c->argv[1],c->argv[2]);if (server.cluster_enabled)clusterPropagatePublish(c->argv[1],c->argv[2]);elseforceCommandPropagation(c,PROPAGATE_REPL);addReplyLongLong(c,receivers);
}/* PUBSUB command for Pub/Sub introspection. */
void pubsubCommand(client *c) {if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"help")) {const char *help[] = {
"CHANNELS [<pattern>]",
"    Return the currently active channels matching a <pattern> (default: '*').",
"NUMPAT",
"    Return number of subscriptions to patterns.",
"NUMSUB [<channel> ...]",
"    Return the number of subscribers for the specified channels, excluding",
"    pattern subscriptions(default: no channels).",
NULL};addReplyHelp(c, help);} else if (!strcasecmp(c->argv[1]->ptr,"channels") &&(c->argc == 2 || c->argc == 3)){/* PUBSUB CHANNELS [<pattern>] */sds pat = (c->argc == 2) ? NULL : c->argv[2]->ptr;dictIterator *di = dictGetIterator(server.pubsub_channels);dictEntry *de;long mblen = 0;void *replylen;replylen = addReplyDeferredLen(c);while((de = dictNext(di)) != NULL) {robj *cobj = dictGetKey(de);sds channel = cobj->ptr;if (!pat || stringmatchlen(pat, sdslen(pat),channel, sdslen(channel),0)){addReplyBulk(c,cobj);mblen++;}}dictReleaseIterator(di);setDeferredArrayLen(c,replylen,mblen);} else if (!strcasecmp(c->argv[1]->ptr,"numsub") && c->argc >= 2) {/* PUBSUB NUMSUB [Channel_1 ... Channel_N] */int j;addReplyArrayLen(c,(c->argc-2)*2);for (j = 2; j < c->argc; j++) {list *l = dictFetchValue(server.pubsub_channels,c->argv[j]);addReplyBulk(c,c->argv[j]);addReplyLongLong(c,l ? listLength(l) : 0);}} else if (!strcasecmp(c->argv[1]->ptr,"numpat") && c->argc == 2) {/* PUBSUB NUMPAT */addReplyLongLong(c,dictSize(server.pubsub_patterns));} else {addReplySubcommandSyntaxError(c);}
}

这篇关于漫话Redis源码之三十六的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/683913。

相关文章

redis群集简单部署过程

redis群集简单部署过程

《redis群集简单部署过程》文章介绍了Redis,一个高性能的键值存储系统,其支持多种数据结构和命令,它还讨论了Redis的服务器端架构、数据存储和获取、协议和命令、高可用性方案、缓存机制以及监控和... 目录Redis介绍1. 基本概念2. 服务器端3. 存储和获取数据4. 协议和命令5. 高可用性6.
阅读更多...
Redis的数据过期策略和数据淘汰策略

Redis的数据过期策略和数据淘汰策略

《Redis的数据过期策略和数据淘汰策略》本文主要介绍了Redis的数据过期策略和数据淘汰策略,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一... 目录一、数据过期策略1、惰性删除2、定期删除二、数据淘汰策略1、数据淘汰策略概念2、8种数据淘汰策略
阅读更多...
Redis存储的列表分页和检索的实现方法

Redis存储的列表分页和检索的实现方法

《Redis存储的列表分页和检索的实现方法》在Redis中,列表（List）是一种有序的数据结构,通常用于存储一系列元素,由于列表是有序的,可以通过索引来访问元素,因此可以很方便地实现分页和检索功能,... 目录一、Redis 列表的基本操作二、分页实现三、检索实现3.1 方法 1：客户端过滤3.2 方法
阅读更多...
Python中操作Redis的常用方法小结

Python中操作Redis的常用方法小结

《Python中操作Redis的常用方法小结》这篇文章主要为大家详细介绍了Python中操作Redis的常用方法,文中的示例代码简洁易懂,具有一定的借鉴价值,有需要的小伙伴可以了解一下... 目录安装Redis开启、关闭Redisredis数据结构redis-cli操作安装redis-py数据库连接和释放增
阅读更多...
redis防止短信恶意调用的实现

redis防止短信恶意调用的实现

《redis防止短信恶意调用的实现》本文主要介绍了在场景登录或注册接口中使用短信验证码时遇到的恶意调用问题,并通过使用Redis分布式锁来解决,具有一定的参考价值,感兴趣的可以了解一下... 目录1.场景2.排查3.解决方案3.1 Redis锁实现3.2 方法调用1.场景登录或注册接口中，使用短信验证码场
阅读更多...
Redis 多规则限流和防重复提交方案实现小结

Redis 多规则限流和防重复提交方案实现小结

《Redis多规则限流和防重复提交方案实现小结》本文主要介绍了Redis多规则限流和防重复提交方案实现小结,包括使用String结构和Zset结构来记录用户IP的访问次数,具有一定的参考价值,感兴趣... 目录一：使用 String 结构记录固定时间段内某用户 IP 访问某接口的次数二：使用 Zset 进行
阅读更多...
解读Redis秒杀优化方案(阻塞队列+基于Stream流的消息队列)

解读Redis秒杀优化方案(阻塞队列+基于Stream流的消息队列)

《解读Redis秒杀优化方案(阻塞队列+基于Stream流的消息队列)》该文章介绍了使用Redis的阻塞队列和Stream流的消息队列来优化秒杀系统的方案,通过将秒杀流程拆分为两条流水线,使用Redi... 目录Redis秒杀优化方案(阻塞队列+Stream流的消息队列)什么是消息队列？消费者组的工作方式每
阅读更多...
Redis如何使用zset处理排行榜和计数问题

Redis如何使用zset处理排行榜和计数问题

《Redis如何使用zset处理排行榜和计数问题》Redis的ZSET数据结构非常适合处理排行榜和计数问题,它可以在高并发的点赞业务中高效地管理点赞的排名,并且由于ZSET的排序特性,可以轻松实现根据... 目录Redis使用zset处理排行榜和计数业务逻辑ZSET 数据结构优化高并发的点赞操作ZSET 结
阅读更多...
Redis的Zset类型及相关命令详细讲解

Redis的Zset类型及相关命令详细讲解

《Redis的Zset类型及相关命令详细讲解》：本文主要介绍Redis的Zset类型及相关命令的相关资料,有序集合Zset是一种Redis数据结构,它类似于集合Set,但每个元素都有一个关联的分数... 目录Zset简介ZADDZCARDZCOUNTZRANGEZREVRANGEZRANGEBYSCOREZ
阅读更多...
Go中sync.Once源码的深度讲解

Go中sync.Once源码的深度讲解

《Go中sync.Once源码的深度讲解》sync.Once是Go语言标准库中的一个同步原语,用于确保某个操作只执行一次,本文将从源码出发为大家详细介绍一下sync.Once的具体使用,x希望对大家有... 目录概念简单示例源码解读总结概念sync.Once是Go语言标准库中的一个同步原语，用于确保某个操
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2