C++ redis使用libevent实现订阅者模式,发现debug。求解决

洋名天下cy 2016-08-10 11:09:35
我使用网上的一篇C++写的redis 使用libevent实现订阅者模式的代码。代码如下
#include <stddef.h>    
#include <string.h>
#include "CRedisSubClient.h"

#include "loggerWrapper.h"

using namespace std;

CRedisSubscriber::CRedisSubscriber():_event_base(0), _event_thread(0),
_redis_context(0)
{
}

CRedisSubscriber::~CRedisSubscriber()
{
}

bool CRedisSubscriber::init(const NotifyMessageCallBack &fn)
{
// initialize the event
_notify_message_fn = fn;
_event_base = event_base_new(); // 创建libevent对象
if (NULL == _event_base)
{
ERROR(" Create redis event failed");
return false;
}

memset(&_event_sem, 0, sizeof(_event_sem));
int ret = sem_init(&_event_sem, 0, 0);
if (ret != 0)
{
ERROR(" Init sem failed.");
return false;
}

return true;
}

bool CRedisSubscriber::uninit()
{
if(_event_base)
{
std::cout<<"LoopBreak:"<<event_base_loopbreak(_event_base)<<std::endl;
event_base_free(_event_base);
_event_base = NULL;
}

sem_destroy(&_event_sem);
return true;
}

bool CRedisSubscriber::connect(const string& ip,int port)
{
// connect redis
_redis_context = redisAsyncConnect(ip.c_str(), port); // 异步连接到redis服务器上,使用默认端口
if (NULL == _redis_context)
{
ERROR(" redisAsyncConnect redis failed.");
return false;
}

if (_redis_context->err)
{
ERROR("Connect redis error: "<< _redis_context->err<<" error:" << _redis_context->errstr); // 输出错误信息
return false;
}

// attach the event
redisLibeventAttach(_redis_context, _event_base); // 将事件绑定到redis context上,使设置给redis的回调跟事件关联

// 创建事件处理线程
int ret = pthread_create(&_event_thread, 0, &CRedisSubscriber::event_thread, this);
if (ret != 0)
{
ERROR("create event thread failed.");
disconnect();
return false;
}

// 设置连接回调,当异步调用连接后,服务器处理连接请求结束后调用,通知调用者连接的状态
redisAsyncSetConnectCallback(_redis_context,&CRedisSubscriber::connect_callback);

// 设置断开连接回调,当服务器断开连接后,通知调用者连接断开,调用者可以利用这个函数实现重连
redisAsyncSetDisconnectCallback(_redis_context,
&CRedisSubscriber::disconnect_callback);

// 启动事件线程
sem_post(&_event_sem);
return true;
}

bool CRedisSubscriber::disconnect()
{
if(_redis_context)
{
redisAsyncDisconnect(_redis_context);
// redisAsyncFree(_redis_context);
_redis_context = NULL;
}
return true;
}

bool CRedisSubscriber::subscribe(const std::string &channel_name)
{
int ret = redisAsyncCommand(_redis_context,
&CRedisSubscriber::command_callback, this, "SUBSCRIBE %s",
channel_name.c_str());
if (REDIS_ERR == ret)
{
ERROR("Subscribe command failed. ret="<< ret);
return false;
}

INFO("Subscribe success: "<< channel_name.c_str());
return true;
}

void CRedisSubscriber::connect_callback(const redisAsyncContext *redis_context,
int status)
{
if (status != REDIS_OK)
{
ERROR("redis订阅模式连接回调,Error:"<< redis_context->errstr);
}
else
{
INFO("redis订阅模式连接成功");
}
}

void CRedisSubscriber::disconnect_callback(
const redisAsyncContext *redis_context, int status)
{
if (status != REDIS_OK)
{
// 这里异常退出,可以尝试重连
ERROR("redis订阅模式断开连接 error:"<<redis_context->errstr);
}
}

// 消息接收回调函数
void CRedisSubscriber::command_callback(redisAsyncContext *redis_context,
void *reply, void *privdata)
{
if (NULL == reply || NULL == privdata) {
return ;
}

// 静态函数中,要使用类的成员变量,把当前的this指针传进来,用this指针间接访问
CRedisSubscriber *self_this = reinterpret_cast<CRedisSubscriber *>(privdata);
redisReply *redis_reply = reinterpret_cast<redisReply *>(reply);

// 订阅接收到的消息是一个带三元素的数组
if (redis_reply->type == REDIS_REPLY_ARRAY && redis_reply->elements == 3)
{
/* INFO("订阅模式收到消息-1:"<<redis_reply->element[0]->str<<" "<<redis_reply->element[0]->len);
INFO("订阅模式收到消息-2:"<<redis_reply->element[1]->str<<" "<<redis_reply->element[1]->len);
INFO("订阅模式收到消息-3:"<<redis_reply->element[2]->str<<" "<<redis_reply->element[2]->len);
*/
// 调用函数对象把消息通知给外层
self_this->_notify_message_fn(redis_reply->element[1]->str,
redis_reply->element[2]->str, redis_reply->element[2]->len);
}
}

void *CRedisSubscriber::event_thread(void *data)
{
if (NULL == data)
{
ERROR("redis订阅模式事件分发失败");
assert(false);
return NULL;
}

CRedisSubscriber *self_this = reinterpret_cast<CRedisSubscriber *>(data);
return self_this->event_proc();
}

void *CRedisSubscriber::event_proc()
{
sem_wait(&_event_sem);

// 开启事件分发,event_base_dispatch会阻塞
event_base_loop(_event_base,EVLOOP_ONCE);
INFO("******event_proc******");
return NULL;
}


现在问题来了,大概有10次会出现1次程序奔溃。奔溃如下:
[err] evmap.c:372: Assertion nwrite >= 0 failed in evmap_io_del
Aborted (core dumped)

然后查看堆栈的问题是:
#0 0x00007f14b64ea5d7 in raise () from /lib64/libc.so.6
#1 0x00007f14b64ebcc8 in abort () from /lib64/libc.so.6
#2 0x00007f14b8338dba in event_exit (errcode=errcode@entry=-559030611) at log.c:79
#3 0x00007f14b833912b in event_errx (eval=eval@entry=-559030611,
fmt=fmt@entry=0x7f14b834e3e8 "%s:%d: Assertion %s failed in %s") at log.c:136
#4 0x00007f14b83384c7 in evmap_io_del (base=<optimized out>, fd=<optimized out>, ev=0x23cfa70) at evmap.c:372
#5 0x00007f14b832730d in event_del_internal (ev=<optimized out>) at event.c:2269
#6 event_del (ev=0x23cfa70) at event.c:2206
#7 0x00007f14b96ed75c in redisLibeventDelWrite (privdata=0x23cf9e0)
at /data/yangchen4/Source/Source/3rdref/redis-2.6/deps/hiredis/adapters/libevent.h:71
#8 0x00007f14b810ddcb in redisAsyncHandleWrite (ac=0x23cf8b0) at /data/yangchen4/libredis/src_linux/async.c:505
#9 0x00007f14b96ed6b6 in redisLibeventWriteEvent (fd=110, event=4, arg=0x23cf9e0)
at /data/yangchen4/Source/Source/3rdref/redis-2.6/deps/hiredis/adapters/libevent.h:51
#10 0x00007f14b832999c in event_process_active_single_queue (activeq=0x23c5c60, base=0x23cf1a0) at event.c:1368
#11 event_process_active (base=<optimized out>) at event.c:1438
#12 event_base_loop (base=0x23cf1a0, flags=1) at event.c:1639
#13 0x00007f14b96ee559 in CRedisSubscriber::event_proc (this=0x23c9c70)
at /data/yangchen4/Source/Source/IntelligentAssistant/CRedisSubClient.cpp:185
#14 0x00007f14b96ee4f2 in CRedisSubscriber::event_thread (data=0x23c9c70)
at /data/yangchen4/Source/Source/IntelligentAssistant/CRedisSubClient.cpp:177
#15 0x00007f14b8567df5 in start_thread () from /lib64/libpthread.so.0
#16 0x00007f14b65ab1ad in clone () from /lib64/libc.so.6

查了一下,发现是在evmap.c文件中的evmap_io_del函数中
if (ev->ev_events & EV_WRITE) {
if (--nwrite == 0)
res |= EV_WRITE;
EVUTIL_ASSERT(nwrite >= 0);
}
由于nwrite<- 导致发生了断言,问题是,这是源码啊。我没有动过啊。纠结。
求大神帮忙


...全文
1763 4 打赏 收藏 转发到动态 举报
写回复
用AI写文章
4 条回复
切换为时间正序
请发表友善的回复…
发表回复
皇天霸 2016-12-02
  • 打赏
  • 举报
回复
你好,我是redis那篇文章的作者,我也遇到相同的问题。我觉得最好的解决方法是在redis的Connect回调connect_callback中将redis连接完成的消息传递给上层。
赵4老师 2016-09-05
  • 打赏
  • 举报
回复
引用 3 楼 u013928720 的回复:
已经解决了。出现问题的原因是,上层调用Init()函数、connect()函数之后,然后马上就调用了subscribe()这个函数。这样是有问题的,因为在调用connect函数,让libevent初始化过程中,有可能libevent还没有初始化完成,此时调用subscribe(),导致libevent接收到监控的redis返回的call_back请求。此时由于libevent初始化没有完成,nwrite=0,到运行到 evmap.c:372: Assertion nwrite >= 0 failed in evmap_io_del 地方,自然就发现问题了。解决方法:在调用subscribe()之前等待几百毫秒;
用延时等待不是特别靠谱。(虽然我一般也是靠延时等待) 正宗的方法应该是等待相应信号。详细请参考《Windows核心编程》
洋名天下cy 2016-08-15
  • 打赏
  • 举报
回复
已经解决了。出现问题的原因是,上层调用Init()函数、connect()函数之后,然后马上就调用了subscribe()这个函数。这样是有问题的,因为在调用connect函数,让libevent初始化过程中,有可能libevent还没有初始化完成,此时调用subscribe(),导致libevent接收到监控的redis返回的call_back请求。此时由于libevent初始化没有完成,nwrite=0,到运行到 evmap.c:372: Assertion nwrite >= 0 failed in evmap_io_del 地方,自然就发现问题了。解决方法:在调用subscribe()之前等待几百毫秒;
赵4老师 2016-08-10
  • 打赏
  • 举报
回复
再正确的源码,你用匪夷所思的错误方法去调用,都很可能会崩溃的。 有时不将“调用函数名字+各参数值,进入函数后各参数值,中间变量值,退出函数前准备返回的值,返回函数到调用处后函数名字+各参数值+返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的,包括捕获各种异常、写日志到屏幕、单步或设断点或生成core文件、……这些方法都不行! 写日志到文件参考下面:
//循环向a函数每次发送200个字节长度(这个是固定的)的buffer,
//a函数中需要将循环传进来的buffer,组成240字节(也是固定的)的新buffer进行处理,
//在处理的时候每次从新buffer中取两个字节打印
#ifdef _MSC_VER
    #pragma warning(disable:4996)
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _MSC_VER
    #include <windows.h>
    #include <process.h>
    #include <io.h>
    #define  MYVOID             void
    #define  vsnprintf          _vsnprintf
#else
    #include <unistd.h>
    #include <sys/time.h>
    #include <pthread.h>
    #define  CRITICAL_SECTION   pthread_mutex_t
    #define  MYVOID             void *
#endif
//Log{
#define MAXLOGSIZE 20000000
#define MAXLINSIZE 16000
#include <time.h>
#include <sys/timeb.h>
#include <stdarg.h>
char logfilename1[]="MyLog1.log";
char logfilename2[]="MyLog2.log";
static char logstr[MAXLINSIZE+1];
char datestr[16];
char timestr[16];
char mss[4];
CRITICAL_SECTION cs_log;
FILE *flog;
#ifdef _MSC_VER
void Lock(CRITICAL_SECTION *l) {
    EnterCriticalSection(l);
}
void Unlock(CRITICAL_SECTION *l) {
    LeaveCriticalSection(l);
}
void sleep_ms(int ms) {
    Sleep(ms);
}
#else
void Lock(CRITICAL_SECTION *l) {
    pthread_mutex_lock(l);
}
void Unlock(CRITICAL_SECTION *l) {
    pthread_mutex_unlock(l);
}
void sleep_ms(int ms) {
    usleep(ms*1000);
}
#endif
void LogV(const char *pszFmt,va_list argp) {
    struct tm *now;
    struct timeb tb;

    if (NULL==pszFmt||0==pszFmt[0]) return;
    vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);
    ftime(&tb);
    now=localtime(&tb.time);
    sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);
    sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );
    sprintf(mss,"%03d",tb.millitm);
    printf("%s %s.%s %s",datestr,timestr,mss,logstr);
    flog=fopen(logfilename1,"a");
    if (NULL!=flog) {
        fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);
        if (ftell(flog)>MAXLOGSIZE) {
            fclose(flog);
            if (rename(logfilename1,logfilename2)) {
                remove(logfilename2);
                rename(logfilename1,logfilename2);
            }
        } else {
            fclose(flog);
        }
    }
}
void Log(const char *pszFmt,...) {
    va_list argp;

    Lock(&cs_log);
    va_start(argp,pszFmt);
    LogV(pszFmt,argp);
    va_end(argp);
    Unlock(&cs_log);
}
//Log}
#define ASIZE    200
#define BSIZE    240
#define CSIZE      2
char Abuf[ASIZE];
char Cbuf[CSIZE];
CRITICAL_SECTION cs_HEX;
CRITICAL_SECTION cs_BBB;
struct FIFO_BUFFER {
    int  head;
    int  tail;
    int  size;
    char data[BSIZE];
} BBB;
int No_Loop=0;
void HexDump(int cn,char *buf,int len) {
    int i,j,k;
    char binstr[80];

    Lock(&cs_HEX);
    for (i=0;i<len;i++) {
        if (0==(i%16)) {
            sprintf(binstr,"%03d %04x -",cn,i);
            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
        } else if (15==(i%16)) {
            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
            sprintf(binstr,"%s  ",binstr);
            for (j=i-15;j<=i;j++) {
                sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
            }
            Log("%s\n",binstr);
        } else {
            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
        }
    }
    if (0!=(i%16)) {
        k=16-(i%16);
        for (j=0;j<k;j++) {
            sprintf(binstr,"%s   ",binstr);
        }
        sprintf(binstr,"%s  ",binstr);
        k=16-k;
        for (j=i-k;j<i;j++) {
            sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
        }
        Log("%s\n",binstr);
    }
    Unlock(&cs_HEX);
}
int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {
    int lent,len1,len2;

    lent=0;
    Lock(cs);
    if (fbuf->size>=len) {
        lent=len;
        if (fbuf->head+lent>BSIZE) {
            len1=BSIZE-fbuf->head;
            memcpy(buf     ,fbuf->data+fbuf->head,len1);
            len2=lent-len1;
            memcpy(buf+len1,fbuf->data           ,len2);
            fbuf->head=len2;
        } else {
            memcpy(buf     ,fbuf->data+fbuf->head,lent);
            fbuf->head+=lent;
        }
        fbuf->size-=lent;
    }
    Unlock(cs);
    return lent;
}
MYVOID thdB(void *pcn) {
    char        *recv_buf;
    int          recv_nbytes;
    int          cn;
    int          wc;
    int          pb;

    cn=(int)pcn;
    Log("%03d thdB              thread begin...\n",cn);
    while (1) {
        sleep_ms(10);
        recv_buf=(char *)Cbuf;
        recv_nbytes=CSIZE;
        wc=0;
        while (1) {
            pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);
            if (pb) {
                Log("%03d recv %d bytes\n",cn,pb);
                HexDump(cn,recv_buf,pb);
                sleep_ms(1);
            } else {
                sleep_ms(1000);
            }
            if (No_Loop) break;//
            wc++;
            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
        }
        if (No_Loop) break;//
    }
#ifndef _MSC_VER
    pthread_exit(NULL);
#endif
}
int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {
    int lent,len1,len2;

    Lock(cs);
    lent=len;
    if (fbuf->size+lent>BSIZE) {
        lent=BSIZE-fbuf->size;
    }
    if (fbuf->tail+lent>BSIZE) {
        len1=BSIZE-fbuf->tail;
        memcpy(fbuf->data+fbuf->tail,buf     ,len1);
        len2=lent-len1;
        memcpy(fbuf->data           ,buf+len1,len2);
        fbuf->tail=len2;
    } else {
        memcpy(fbuf->data+fbuf->tail,buf     ,lent);
        fbuf->tail+=lent;
    }
    fbuf->size+=lent;
    Unlock(cs);
    return lent;
}
MYVOID thdA(void *pcn) {
    char        *send_buf;
    int          send_nbytes;
    int          cn;
    int          wc;
    int           a;
    int          pa;

    cn=(int)pcn;
    Log("%03d thdA              thread begin...\n",cn);
    a=0;
    while (1) {
        sleep_ms(100);
        memset(Abuf,a,ASIZE);
        a=(a+1)%256;
        if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop
        send_buf=(char *)Abuf;
        send_nbytes=ASIZE;
        Log("%03d sending %d bytes\n",cn,send_nbytes);
        HexDump(cn,send_buf,send_nbytes);
        wc=0;
        while (1) {
            pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);
            Log("%03d sent %d bytes\n",cn,pa);
            HexDump(cn,send_buf,pa);
            send_buf+=pa;
            send_nbytes-=pa;
            if (send_nbytes<=0) break;//
            sleep_ms(1000);
            if (No_Loop) break;//
            wc++;
            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
        }
        if (No_Loop) break;//
    }
#ifndef _MSC_VER
    pthread_exit(NULL);
#endif
}
int main() {
#ifdef _MSC_VER
    InitializeCriticalSection(&cs_log);
    InitializeCriticalSection(&cs_HEX);
    InitializeCriticalSection(&cs_BBB);
#else
    pthread_t threads[2];
    int threadsN;
    int rc;
    pthread_mutex_init(&cs_log,NULL);
    pthread_mutex_init(&cs_HEX,NULL);
    pthread_mutex_init(&cs_BBB,NULL);
#endif
    Log("Start===========================================================\n");

    BBB.head=0;
    BBB.tail=0;
    BBB.size=0;

#ifdef _MSC_VER
    _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);
    _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2);
#else
    threadsN=0;
    rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
    rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
#endif

    if (!access("No_Loop",0)) {
        remove("No_Loop");
        if (!access("No_Loop",0)) {
            No_Loop=1;
        }
    }
    while (1) {
        sleep_ms(1000);
        if (No_Loop) break;//
        if (!access("No_Loop",0)) {
            No_Loop=1;
        }
    }
    sleep_ms(3000);
    Log("End=============================================================\n");
#ifdef _MSC_VER
    DeleteCriticalSection(&cs_BBB);
    DeleteCriticalSection(&cs_HEX);
    DeleteCriticalSection(&cs_log);
#else
    pthread_mutex_destroy(&cs_BBB);
    pthread_mutex_destroy(&cs_HEX);
    pthread_mutex_destroy(&cs_log);
#endif
    return 0;
}
洋名天下cy 2016-08-10
  • 打赏
  • 举报
回复
是nwrite 小于0 导致发生断言。这是为什么?

3,882

社区成员

发帖
与我相关
我的任务
社区描述
C/C++ 其它技术问题
社区管理员
  • 其它技术问题社区
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧