漫话Redis源码之一百零六

最新推荐文章于 2023-12-14 19:44:18 发布
最新推荐文章于 2023-12-14 19:44:18 发布
阅读量723 收藏
点赞数 1
分类专栏： S1: C/C++ s2: 实用代码 文章标签： redis 数据库 database
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stpeace/article/details/123317119
版权
此代码示例展示了如何在 Redis 模块中实现阻塞命令，如 BLOCK.DEBUG 和 BLOCK.DOUBLE_DEBUG。这些命令会阻塞客户端一段时间，然后返回一个随机数。在阻塞期间，可以测量执行时间并记录。如果超时，则返回 'Request timed out'。此外，还提供了处理客户端断开连接的回调函数。整个过程涉及线程创建、参数传递和资源管理。
摘要由CSDN通过智能技术生成

blocking command相关的操作，简单看一下就行了：

#define UNUSED(x) (void)(x)

/* Reply callback for blocking command BLOCK.DEBUG */
int HelloBlock_Reply(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    UNUSED(argv);
    UNUSED(argc);
    int *myint = RedisModule_GetBlockedClientPrivateData(ctx);
    return RedisModule_ReplyWithLongLong(ctx,*myint);
}

/* Timeout callback for blocking command BLOCK.DEBUG */
int HelloBlock_Timeout(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    UNUSED(argv);
    UNUSED(argc);
    RedisModuleBlockedClient *bc = RedisModule_GetBlockedClientHandle(ctx);
    RedisModule_BlockedClientMeasureTimeEnd(bc);
    return RedisModule_ReplyWithSimpleString(ctx,"Request timedout");
}

/* Private data freeing callback for BLOCK.DEBUG command. */
void HelloBlock_FreeData(RedisModuleCtx *ctx, void *privdata) {
    UNUSED(ctx);
    RedisModule_Free(privdata);
}

/* The thread entry point that actually executes the blocking part
 * of the command BLOCK.DEBUG. */
void *BlockDebug_ThreadMain(void *arg) {
    void **targ = arg;
    RedisModuleBlockedClient *bc = targ[0];
    long long delay = (unsigned long)targ[1];
    long long enable_time_track = (unsigned long)targ[2];
    if (enable_time_track)
        RedisModule_BlockedClientMeasureTimeStart(bc);
    RedisModule_Free(targ);

    struct timespec ts;
    ts.tv_sec = delay / 1000;
    ts.tv_nsec = (delay % 1000) * 1000000;
    nanosleep(&ts, NULL);
    int *r = RedisModule_Alloc(sizeof(int));
    *r = rand();
    if (enable_time_track)
        RedisModule_BlockedClientMeasureTimeEnd(bc);
    RedisModule_UnblockClient(bc,r);
    return NULL;
}

/* The thread entry point that actually executes the blocking part
 * of the command BLOCK.DOUBLE_DEBUG. */
void *DoubleBlock_ThreadMain(void *arg) {
    void **targ = arg;
    RedisModuleBlockedClient *bc = targ[0];
    long long delay = (unsigned long)targ[1];
    RedisModule_BlockedClientMeasureTimeStart(bc);
    RedisModule_Free(targ);
    struct timespec ts;
    ts.tv_sec = delay / 1000;
    ts.tv_nsec = (delay % 1000) * 1000000;
    nanosleep(&ts, NULL);
    int *r = RedisModule_Alloc(sizeof(int));
    *r = rand();
    RedisModule_BlockedClientMeasureTimeEnd(bc);
    /* call again RedisModule_BlockedClientMeasureTimeStart() and
     * RedisModule_BlockedClientMeasureTimeEnd and ensure that the
     * total execution time is 2x the delay. */
    RedisModule_BlockedClientMeasureTimeStart(bc);
    nanosleep(&ts, NULL);
    RedisModule_BlockedClientMeasureTimeEnd(bc);

    RedisModule_UnblockClient(bc,r);
    return NULL;
}

void HelloBlock_Disconnected(RedisModuleCtx *ctx, RedisModuleBlockedClient *bc) {
    RedisModule_Log(ctx,"warning","Blocked client %p disconnected!",
        (void*)bc);
}

/* BLOCK.DEBUG <delay_ms> <timeout_ms> -- Block for <count> milliseconds, then reply with
 * a random number. Timeout is the command timeout, so that you can test
 * what happens when the delay is greater than the timeout. */
int HelloBlock_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc != 3) return RedisModule_WrongArity(ctx);
    long long delay;
    long long timeout;

    if (RedisModule_StringToLongLong(argv[1],&delay) != REDISMODULE_OK) {
        return RedisModule_ReplyWithError(ctx,"ERR invalid count");
    }

    if (RedisModule_StringToLongLong(argv[2],&timeout) != REDISMODULE_OK) {
        return RedisModule_ReplyWithError(ctx,"ERR invalid count");
    }

    pthread_t tid;
    RedisModuleBlockedClient *bc = RedisModule_BlockClient(ctx,HelloBlock_Reply,HelloBlock_Timeout,HelloBlock_FreeData,timeout);

    /* Here we set a disconnection handler, however since this module will
     * block in sleep() in a thread, there is not much we can do in the
     * callback, so this is just to show you the API. */
    RedisModule_SetDisconnectCallback(bc,HelloBlock_Disconnected);

    /* Now that we setup a blocking client, we need to pass the control
     * to the thread. However we need to pass arguments to the thread:
     * the delay and a reference to the blocked client handle. */
    void **targ = RedisModule_Alloc(sizeof(void*)*3);
    targ[0] = bc;
    targ[1] = (void*)(unsigned long) delay;
    // pass 1 as flag to enable time tracking
    targ[2] = (void*)(unsigned long) 1;

    if (pthread_create(&tid,NULL,BlockDebug_ThreadMain,targ) != 0) {
        RedisModule_AbortBlock(bc);
        return RedisModule_ReplyWithError(ctx,"-ERR Can't start thread");
    }
    return REDISMODULE_OK;
}

/* BLOCK.DEBUG_NOTRACKING <delay_ms> <timeout_ms> -- Block for <count> milliseconds, then reply with
 * a random number. Timeout is the command timeout, so that you can test
 * what happens when the delay is greater than the timeout.
 * this command does not track background time so the background time should no appear in stats*/
int HelloBlockNoTracking_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc != 3) return RedisModule_WrongArity(ctx);
    long long delay;
    long long timeout;

    if (RedisModule_StringToLongLong(argv[1],&delay) != REDISMODULE_OK) {
        return RedisModule_ReplyWithError(ctx,"ERR invalid count");
    }

    if (RedisModule_StringToLongLong(argv[2],&timeout) != REDISMODULE_OK) {
        return RedisModule_ReplyWithError(ctx,"ERR invalid count");
    }

    pthread_t tid;
    RedisModuleBlockedClient *bc = RedisModule_BlockClient(ctx,HelloBlock_Reply,HelloBlock_Timeout,HelloBlock_FreeData,timeout);

    /* Here we set a disconnection handler, however since this module will
     * block in sleep() in a thread, there is not much we can do in the
     * callback, so this is just to show you the API. */
    RedisModule_SetDisconnectCallback(bc,HelloBlock_Disconnected);

    /* Now that we setup a blocking client, we need to pass the control
     * to the thread. However we need to pass arguments to the thread:
     * the delay and a reference to the blocked client handle. */
    void **targ = RedisModule_Alloc(sizeof(void*)*3);
    targ[0] = bc;
    targ[1] = (void*)(unsigned long) delay;
    // pass 0 as flag to enable time tracking
    targ[2] = (void*)(unsigned long) 0;

    if (pthread_create(&tid,NULL,BlockDebug_ThreadMain,targ) != 0) {
        RedisModule_AbortBlock(bc);
        return RedisModule_ReplyWithError(ctx,"-ERR Can't start thread");
    }
    return REDISMODULE_OK;
}

/* BLOCK.DOUBLE_DEBUG <delay_ms> -- Block for 2 x <count> milliseconds,
 * then reply with a random number.
 * This command is used to test multiple calls to RedisModule_BlockedClientMeasureTimeStart()
 * and RedisModule_BlockedClientMeasureTimeEnd() within the same execution. */
int HelloDoubleBlock_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc != 2) return RedisModule_WrongArity(ctx);
    long long delay;

    if (RedisModule_StringToLongLong(argv[1],&delay) != REDISMODULE_OK) {
        return RedisModule_ReplyWithError(ctx,"ERR invalid count");
    }

    pthread_t tid;
    RedisModuleBlockedClient *bc = RedisModule_BlockClient(ctx,HelloBlock_Reply,HelloBlock_Timeout,HelloBlock_FreeData,0);

    /* Now that we setup a blocking client, we need to pass the control
     * to the thread. However we need to pass arguments to the thread:
     * the delay and a reference to the blocked client handle. */
    void **targ = RedisModule_Alloc(sizeof(void*)*2);
    targ[0] = bc;
    targ[1] = (void*)(unsigned long) delay;

    if (pthread_create(&tid,NULL,DoubleBlock_ThreadMain,targ) != 0) {
        RedisModule_AbortBlock(bc);
        return RedisModule_ReplyWithError(ctx,"-ERR Can't start thread");
    }
    return REDISMODULE_OK;
}

RedisModuleBlockedClient *blocked_client = NULL;

/* BLOCK.BLOCK [TIMEOUT] -- Blocks the current client until released
 * or TIMEOUT seconds. If TIMEOUT is zero, no timeout function is
 * registered.
 */
int Block_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (RedisModule_IsBlockedReplyRequest(ctx)) {
        RedisModuleString *r = RedisModule_GetBlockedClientPrivateData(ctx);
        return RedisModule_ReplyWithString(ctx, r);
    } else if (RedisModule_IsBlockedTimeoutRequest(ctx)) {
        RedisModule_UnblockClient(blocked_client, NULL); /* Must be called to avoid leaks. */
        blocked_client = NULL;
        return RedisModule_ReplyWithSimpleString(ctx, "Timed out");
    }

    if (argc != 2) return RedisModule_WrongArity(ctx);
    long long timeout;

    if (RedisModule_StringToLongLong(argv[1], &timeout) != REDISMODULE_OK) {
        return RedisModule_ReplyWithError(ctx, "ERR invalid timeout");
    }
    if (blocked_client) {
        return RedisModule_ReplyWithError(ctx, "ERR another client already blocked");
    }

    /* Block client. We use this function as both a reply and optional timeout
     * callback and differentiate the different code flows above.
     */
    blocked_client = RedisModule_BlockClient(ctx, Block_RedisCommand,
            timeout > 0 ? Block_RedisCommand : NULL, NULL, timeout);
    return REDISMODULE_OK;
}

/* BLOCK.IS_BLOCKED -- Returns 1 if we have a blocked client, or 0 otherwise.
 */
int IsBlocked_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    UNUSED(argv);
    UNUSED(argc);
    RedisModule_ReplyWithLongLong(ctx, blocked_client ? 1 : 0);
    return REDISMODULE_OK;
}

/* BLOCK.RELEASE [reply] -- Releases the blocked client and produce the specified reply.
 */
int Release_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    if (argc != 2) return RedisModule_WrongArity(ctx);
    if (!blocked_client) {
        return RedisModule_ReplyWithError(ctx, "ERR No blocked client");
    }

    RedisModuleString *replystr = argv[1];
    RedisModule_RetainString(ctx, replystr);
    int err = RedisModule_UnblockClient(blocked_client, replystr);
    blocked_client = NULL;

    RedisModule_ReplyWithSimpleString(ctx, "OK");

    return REDISMODULE_OK;
}

int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
    UNUSED(argv);
    UNUSED(argc);

    if (RedisModule_Init(ctx,"block",1,REDISMODULE_APIVER_1)
        == REDISMODULE_ERR) return REDISMODULE_ERR;

    if (RedisModule_CreateCommand(ctx,"block.debug",
        HelloBlock_RedisCommand,"",0,0,0) == REDISMODULE_ERR)
        return REDISMODULE_ERR;

    if (RedisModule_CreateCommand(ctx,"block.double_debug",
        HelloDoubleBlock_RedisCommand,"",0,0,0) == REDISMODULE_ERR)
        return REDISMODULE_ERR;

    if (RedisModule_CreateCommand(ctx,"block.debug_no_track",
        HelloBlockNoTracking_RedisCommand,"",0,0,0) == REDISMODULE_ERR)
        return REDISMODULE_ERR;

    if (RedisModule_CreateCommand(ctx, "block.block",
        Block_RedisCommand, "", 0, 0, 0) == REDISMODULE_ERR)
        return REDISMODULE_ERR;

    if (RedisModule_CreateCommand(ctx,"block.is_blocked",
        IsBlocked_RedisCommand,"",0,0,0) == REDISMODULE_ERR)
        return REDISMODULE_ERR;

    if (RedisModule_CreateCommand(ctx,"block.release",
        Release_RedisCommand,"",0,0,0) == REDISMODULE_ERR)
        return REDISMODULE_ERR;

    return REDISMODULE_OK;
}

涛歌依旧
关注
专栏目录
漫话UDS之Service 11
Soly_kun的博客
08-07 906
List item 漫话UDS之Service 11 对于80后，你是否遇到过这样的场景： 在以往去街面上网吧玩，由于是花钱，恨不得充分利用手头电脑，比如在玩游戏时，会打开自己感兴趣的视频播放，在游戏空闲期或者开个小窗口两不误。这种场景下经常会遇到电脑屏幕蓝屏或者卡死????。 这个时候第一反应就是大喊一声：“网管”，而对于网管，高兴的时候会跑到出问题电脑旁边查看问题，遇到正在起兴玩游戏的，则会回复一句：“重启”。 电脑重启，如同人在身心俱疲状态，大睡一觉后的满血复活，电脑在重启后也会将运行的各种程序进程
漫话Redis源码之七十
认知 行动 坚持
01-23 1034
/* Test main */ #ifdef REDIS_TEST #include <stdio.h> #define UNUSED(x) (void)(x) int crc64Test(int argc, char *argv[], int accurate) { UNUSED(argc); UNUSED(argv); UNUSED(accurate); crc64_init(); printf("[calcula]: e9c6d914c4...
记录一些C/C++,QT编译问题及其解决方法
路过的熊的博客
03-01 410
未使用参数警告 #define UNUSED(x) (void)(x) //适用于所有GCC平台 补充中 … … …
UNUSED宏作用
最新发布
Erice_s的博客
12-14 845
UNUSED宏作用
#define UNUSED_PARA(x) (void)(x) 用法
Eng_ingLi的博客
11-13 295
#define UNUSED_PARA(X) (void)(x)的用法
关于宏定义的几个问题
Donven的博客
04-18 706
1、#ifndef   UNUSED_PARAM #define   UNUSED_PARAM(v)   (void)(v) #endif 假如一个有返回值的函数 如调用时是没有使用它的返回值，编译器会给出一个警告 如果用void强制转换一下，则明确告诉编译器不使用返回值 也就是为了消除警告2、#define UNUSED(x) ((x) = (x))这个表示，如果有一个函数调用时，传参没有进行赋...
漫话数学.pdf
05-13
第一章 从计算机说起 第二章 数是什么 第三章 运算的规律 第四章 怎样才能算的快 第五章 对数、算尺与算图 ……
《漫话e》作者: 李大潜 编 出版年: 2011年
05-24
一、对数——化乘除为加减二、常用对数三、对数的尺度四、e的现身——从一个复利问题谈起五、自然指数函数和自然对数函数六、无所不在的e七、离不开e的奇妙曲线八、由实变数到复变数附表 常用对数的尾数表(兼作常用...
漫话互联网产品经理ppt课件.pptx
11-12
【漫话互联网产品经理】课程旨在深入探讨互联网产品经理这一角色，帮助学员全面了解产品经理的工作内容、职责以及所需的技能。课程从“什么是产品经理”开始，强调产品经理是产品的守护者，负责产品从构思到终结的全...
《解码三大数学常数：e的密码》《漫话e》
05-25
《解码三大数学常数：e的密码》与《漫话e》这两本书都是关于数学常数e的科普读物，旨在深入浅出地介绍这个神秘而重要的数学概念。数学常数e，通常表示为2.71828…，在数学中占据着至关重要的地位，它不仅在自然对数...
Redis Module 模块组件
S_ZaiJiangHu的博客
10-13 2299
Redis 本身有比较丰富的数据类型，例如 String、Hash、Set、ListJSON 是我们常用的数据类型，当我们需要在 Redis 中保存 json 数据时是怎么存放的呢？虽然 Redis 有大量的核心数据结构，但是没有一个符合 JSON 的要求。当然可以通过使用其他数据类型来解决问题：比如在实际项目中，我们经常会使用 Strings 来存储原始的序列化 JSON 串；或者使用 Hashes 来展示 JSON 对象。但是这并不是原生的 JSON，并且只是在少数地方去用。
Redis【有与无】【API-3】在Redis模块中阻塞（Blocking）命令
琴韵悠悠
12-01 1691
本文基于Redis 6.0.9版本，前提至少 Redis 3.0或更高版本。 目录 1.在Redis模块中阻塞（Blocking）命令 1.1.阻塞和恢复的工作方式 1.2.解除阻塞时传递回复数据 1.3.中止阻塞客户 1.4.使用单个函数实现命令，回复和超时回调 1.5.在线程内处理数据副本 1.6.未来的工作 1.在Redis模块中阻塞（Blocking）命令 Redis的内置命令集中有一些阻塞命令。 最常用的一种是BLPOP（或symmetricBLPOP），它阻塞等待元素...
警告“未引用的形参/局部变量”的消除方法
热门推荐
天律界中子之不写博客不读书
11-29 2万+
如果我们编译以下代码：#include <stdio.h>int main(int argc, char** argv) { int n; int nRet = printf("Hello, world!"); return 0; }编译器一般会发出以下警告(VS2015)：1>f:\mycode\cpptest\main.cpp(55): warning C4100
漫话Redis源码之六十四
认知 行动 坚持
01-23 360
#include <stdint.h> /* Toggle the 16 bit unsigned integer pointed by *p from little endian to * big endian */ void memrev16(void *p) { unsigned char *x = p, t; t = x[0]; x[0] = x[1]; x[1] = t; } /* Toggle the 32 bit unsigned ...
redis 的事件调度
江南夜雨
08-21 284
redis 的过期key 的删除策略有三种 惰性删除 定时删除 定期删除 上面三种的区别自行搜索，这里主要围绕 3 展开 关于redis 有几个线程，上篇文章有介绍，但还有一个问题，redis 处理 过期key的线程和 接受请求的线程是不是同一个？如果是它们是怎么协调的 首先，它们是同一个线程，具体的实现是通过利用时间分片的方式解决的 redis 分为两种事件，时间事件和文件事件，文件事件也就是处理客户端请求，时间事件是指周期性的处理一些后台任务，后台任务不一定就..
Blocking commands in Redis modules
weixin_33910460的博客
02-28 175
Redis has a few blocking commands among the built-in set of commands. One of the most used isBLPOP(or the symmetricBRPOP) which blocks waiting for elements arriving in a lis...
Redis服务启动、事件循环与客户端命令的执行
hustzw07的博客
07-22 598
Redis 服务启动 直接看代码。新的版本中服务器启动代码在 server.c 中 int main(int argc, char **argv) { struct timeval tv; int j; // 省略 ... initServerConfig(); moduleInitModulesSystem(); if (argc >= 2) { // ... resetServerSaveParam
Qt下编译警告unused parameter ，参数未使用
wajh07的专栏
06-04 2万+
编译中出现以下警告：  warning: unused parameter ‘arg1′ [-Wunused-parameter] 原因是由于函数参数未使用，这在程序当中有时候很正常；所以个人认为此警告意义不大，可以取消；   方法一： 在提示警告函数里面添加 Q_UNUSED(arg1); 方法二： 在pro工程文件最后加入如下代码： QMAKE_CXXFLAGS +=  -W
消除编译器未使用的警告
program is a art
03-29 409
#define XXX_UNUSED(x) (void)x;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值