漫话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。

相关文章

Java调用C++动态库超详细步骤讲解(附源码)

Java调用C++动态库超详细步骤讲解(附源码)

《Java调用C++动态库超详细步骤讲解(附源码)》C语言因其高效和接近硬件的特性,时常会被用在性能要求较高或者需要直接操作硬件的场合,：本文主要介绍Java调用C++动态库的相关资料,文中通过代... 目录一、直接调用C++库第一步：动态库生成（vs2017+qt5.12.10）第二步：Java调用C++
阅读更多...
Redis分片集群的实现

Redis分片集群的实现

《Redis分片集群的实现》Redis分片集群是一种将Redis数据库分散到多个节点上的方式,以提供更高的性能和可伸缩性,本文主要介绍了Redis分片集群的实现,具有一定的参考价值,感兴趣的可以了解一... 目录1. Redis Cluster的核心概念哈希槽（Hash Slots）主从复制与故障转移2.
阅读更多...
Python实现无痛修改第三方库源码的方法详解

Python实现无痛修改第三方库源码的方法详解

《Python实现无痛修改第三方库源码的方法详解》很多时候,我们下载的第三方库是不会有需求不满足的情况,但也有极少的情况,第三方库没有兼顾到需求,本文将介绍几个修改源码的操作,大家可以根据需求进行选择... 目录需求不符合模拟示例 1. 修改源文件2. 继承修改3. 猴子补丁4. 追踪局部变量需求不符合很
阅读更多...
Redis 中的热点键和数据倾斜示例详解

Redis 中的热点键和数据倾斜示例详解

《Redis中的热点键和数据倾斜示例详解》热点键是指在Redis中被频繁访问的特定键,这些键由于其高访问频率,可能导致Redis服务器的性能问题,尤其是在高并发场景下,本文给大家介绍Redis中的热... 目录Redis 中的热点键和数据倾斜热点键（Hot Key）定义特点应对策略示例数据倾斜（Data S
阅读更多...
redis+lua实现分布式限流的示例

redis+lua实现分布式限流的示例

《redis+lua实现分布式限流的示例》本文主要介绍了redis+lua实现分布式限流的示例,可以实现复杂的限流逻辑,如滑动窗口限流,并且避免了多步操作导致的并发问题,具有一定的参考价值,感兴趣的可... 目录为什么使用Redis+Lua实现分布式限流使用ZSET也可以实现限流，为什么选择lua的方式实现
阅读更多...
Redis中管道操作pipeline的实现

Redis中管道操作pipeline的实现

《Redis中管道操作pipeline的实现》RedisPipeline是一种优化客户端与服务器通信的技术,通过批量发送和接收命令减少网络往返次数,提高命令执行效率,本文就来介绍一下Redis中管道操... 目录什么是pipeline场景一:我要向Redis新增大批量的数据分批处理事务（ MULTI/EXE
阅读更多...
Redis中高并发读写性能的深度解析与优化

Redis中高并发读写性能的深度解析与优化

《Redis中高并发读写性能的深度解析与优化》Redis作为一款高性能的内存数据库,广泛应用于缓存、消息队列、实时统计等场景,本文将深入探讨Redis的读写并发能力,感兴趣的小伙伴可以了解下... 目录引言一、Redis 并发能力概述1.1 Redis 的读写性能1.2 影响 Redis 并发能力的因素二、
阅读更多...
Redis中的常用的五种数据类型详解

Redis中的常用的五种数据类型详解

《Redis中的常用的五种数据类型详解》：本文主要介绍Redis中的常用的五种数据类型详解,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Redis常用的五种数据类型一、字符串（String）简介常用命令应用场景二、哈希（Hash）简介常用命令应用场景三、列表（L
阅读更多...
Redis解决缓存击穿问题的两种方法

Redis解决缓存击穿问题的两种方法

《Redis解决缓存击穿问题的两种方法》缓存击穿问题也叫热点Key问题,就是⼀个被高并发访问并且缓存重建业务较复杂的key突然失效了,无数的请求访问会在瞬间给数据库带来巨大的冲击,本文给大家介绍了Re... 目录引言解决办法互斥锁（强一致，性能差）逻辑过期（高可用，性能优）设计逻辑过期时间引言缓存击穿：给
阅读更多...
Redis中如何实现商品秒杀

Redis中如何实现商品秒杀

《Redis中如何实现商品秒杀》：本文主要介绍Redis中如何实现商品秒杀问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录技术栈功能实现步骤步骤一：准备商品库存数据步骤二：实现商品秒杀步骤三：优化Redis性能技术讲解Redis的List类型Redis的Set
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2