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

相关文章

Knife4j+Axios+Redis前后端分离架构下的 API 管理与会话方案(最新推荐)

Knife4j+Axios+Redis前后端分离架构下的 API 管理与会话方案(最新推荐)

《Knife4j+Axios+Redis前后端分离架构下的API管理与会话方案(最新推荐)》本文主要介绍了Swagger与Knife4j的配置要点、前后端对接方法以及分布式Session实现原理,... 目录一、Swagger 与 Knife4j 的深度理解及配置要点Knife4j 配置关键要点1.Spri
阅读更多...
Redis出现中文乱码的问题及解决

Redis出现中文乱码的问题及解决

《Redis出现中文乱码的问题及解决》：本文主要介绍Redis出现中文乱码的问题及解决,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1. 问题的产生2China编程. 问题的解决redihttp://www.chinasem.cns数据进制问题的解决中文乱码问题解决总结
阅读更多...
Redis的持久化之RDB和AOF机制详解

Redis的持久化之RDB和AOF机制详解

《Redis的持久化之RDB和AOF机制详解》：本文主要介绍Redis的持久化之RDB和AOF机制,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录概述RDB（Redis Database）核心原理触发方式手动触发自动触发AOF（Append-Only File）核
阅读更多...
Redis分片集群、数据读写规则问题小结

Redis分片集群、数据读写规则问题小结

《Redis分片集群、数据读写规则问题小结》本文介绍了Redis分片集群的原理,通过数据分片和哈希槽机制解决单机内存限制与写瓶颈问题,实现分布式存储和高并发处理,但存在通信开销大、维护复杂及对事务支持... 目录一、分片集群解android决的问题二、分片集群图解 分片集群特征如何解决的上述问题？（与哨兵模
阅读更多...
SpringBoot连接Redis集群教程

SpringBoot连接Redis集群教程

《SpringBoot连接Redis集群教程》：本文主要介绍SpringBoot连接Redis集群教程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1. 依赖2. 修改配置文件3. 创建RedisClusterConfig4. 测试总结1. 依赖 <de
阅读更多...
SpringBoot+Redis防止接口重复提交问题

SpringBoot+Redis防止接口重复提交问题

《SpringBoot+Redis防止接口重复提交问题》：本文主要介绍SpringBoot+Redis防止接口重复提交问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不... 目录前言实现思路代码示例测试总结前言在项目的使用使用过程中，经常会出现某些操作在短时间内频繁提交。例
阅读更多...
Redis 配置文件使用建议redis.conf 从入门到实战

Redis 配置文件使用建议redis.conf 从入门到实战

《Redis配置文件使用建议redis.conf从入门到实战》Redis配置方式包括配置文件、命令行参数、运行时CONFIG命令,支持动态修改参数及持久化,常用项涉及端口、绑定、内存策略等,版本8... 目录一、Redis.conf 是什么？二、命令行方式传参（适用于测试）三、运行时动态修改配置（不重启服务
阅读更多...
浅析如何保证MySQL与Redis数据一致性

浅析如何保证MySQL与Redis数据一致性

《浅析如何保证MySQL与Redis数据一致性》在互联网应用中,MySQL作为持久化存储引擎,Redis作为高性能缓存层,两者的组合能有效提升系统性能,下面我们来看看如何保证两者的数据一致性吧... 目录一、数据不一致性的根源1.1 典型不一致场景1.2 关键矛盾点二、一致性保障策略2.1 基础策略：更新数
阅读更多...
Redis Cluster模式配置

Redis Cluster模式配置

《RedisCluster模式配置》：本文主要介绍RedisCluster模式配置,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录分片 一、分片的本质与核心价值二、分片实现方案对比 ‌三、分片算法详解1. ‌范围分片（顺序分片）‌2. ‌哈希分片3. ‌虚
阅读更多...
Springboot整合Redis主从实践

Springboot整合Redis主从实践

《Springboot整合Redis主从实践》：本文主要介绍Springboot整合Redis主从的实例,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录前言原配置现配置测试LettuceConnectionFactory.setShareNativeConnect
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2