redis源码分析之t_string.c

最新推荐文章于 2022-04-20 22:03:02 发布
最新推荐文章于 2022-04-20 22:03:02 发布
阅读量1.2k 收藏
点赞数
分类专栏： C/C++/MFC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itbuluoge/article/details/21457869
版权

redis源码分析之t_string.c，该文件是处理string类型的源文件，注释略去，具体分析如下：



#include "redis.h"	//引入头文件
#include <math.h> /* isnan(), isinf() */  //引入库文件  主要是用到isnan函数和isinf函数  分别是判断是否是数字和是否是无限数字的函数

/*-----------------------------------------------------------------------------
 * String Commands
 *----------------------------------------------------------------------------*/


//静态函数  用来判断客户端提交的数字是否超过了512MB
static int checkStringLength(redisClient *c, long long size) {
    if (size > 512*1024*1024) {
	//返回客户端一个错误命令
        addReplyError(c,"string exceeds maximum allowed size (512MB)");
	//向系统返回一个错误
        return REDIS_ERR;
    }
    return REDIS_OK;
}

/* The setGenericCommand() function implements the SET operation with different
 * options and variants. This function is called in order to implement the
 * following commands: SET, SETEX, PSETEX, SETNX.
 *
 * 'flags' changes the behavior of the command (NX or XX, see belove).
 *
 * 'expire' represents an expire to set in form of a Redis object as passed
 * by the user. It is interpreted according to the specified 'unit'.
 *
 * 'ok_reply' and 'abort_reply' is what the function will reply to the client
 * if the operation is performed, or when it is not because of NX or
 * XX flags.
 *
 * If ok_reply is NULL "+OK" is used.
 * If abort_reply is NULL, "$-1" is used. */

#define REDIS_SET_NO_FLAGS 0
//移位宏定义
#define REDIS_SET_NX (1<<0)     /* Set if key not exists. */
#define REDIS_SET_XX (1<<1)     /* Set if key exists. */


//处理客户端发来的SET命令统一处理函数   下面会继续看到SET系列的具体函数。每个SET函数在完成处理之后，统一调用
//setGenericCommand函数
void setGenericCommand(redisClient *c, int flags, robj *key, robj *val, robj *expire, int unit, robj *ok_reply, robj *abort_reply) { long long milliseconds = 0;
 /* initialized to avoid any harmness warning */ if (expire) { if (getLongLongFromObjectOrReply(c, expire, &milliseconds, NULL) != REDIS_OK) return; if (milliseconds <= 0) { addReplyError(c,"invalid expire time in SETEX"); return; } if (unit == UNIT_SECONDS)
 milliseconds *= 1000; } if ((flags & REDIS_SET_NX && lookupKeyWrite(c->db,key) != NULL) || (flags & REDIS_SET_XX && lookupKeyWrite(c->db,key) == NULL)) {



//向客户端返回数据   具体关于addreply的函数介绍见链接：http://www.petermao.com/redis/114.html
        addReply(c, abort_reply ? abort_reply : shared.nullbulk);
        return;
    }
//在数据库中设计key和value值
    setKey(c->db,key,val);
//脏数据加1，表示更改了原有数据，需要系统更新到磁盘中去
    server.dirty++;
    if (expire) setExpire(c->db,key,mstime()+milliseconds);
//事件通知 默认是关闭的 详细见链接 http://www.redisdoc.com/en/latest/topic/notification.html
    notifyKeyspaceEvent(REDIS_NOTIFY_STRING,"set",key,c->db->id);
    if (expire) notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,
        "expire",key,c->db->id);
    addReply(c, ok_reply ? ok_reply : shared.ok);
}

/* SET key value [NX] [XX] [EX <seconds>] [PX <milliseconds>] */
//据图的SET命令 包括SETNX SETXX SETEX。
void setCommand(redisClient *c) {
    int j;
    robj *expire = NULL;
    int unit = UNIT_SECONDS;
    int flags = REDIS_SET_NO_FLAGS;
//以下是解析参数的过程
    for (j = 3; j < c->argc; j++) {
        char *a = c->argv[j]->ptr;
        robj *next = (j == c->argc-1) ? NULL : c->argv[j+1];

        if ((a[0] == 'n' || a[0] == 'N') &&
            (a[1] == 'x' || a[1] == 'X') && a[2] == '\0') {
            flags |= REDIS_SET_NX;
        } else if ((a[0] == 'x' || a[0] == 'X') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0') {
            flags |= REDIS_SET_XX;
        } else if ((a[0] == 'e' || a[0] == 'E') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' && next) {
            unit = UNIT_SECONDS;
            expire = next;
            j++;
        } else if ((a[0] == 'p' || a[0] == 'P') &&
                   (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' && next) {
            unit = UNIT_MILLISECONDS;
            expire = next;
            j++;
        } else {
//shared是一个共享变量  
//Shared objects

            addReply(c,shared.syntaxerr);
            return;
        }
    }

    c->argv[2] = tryObjectEncoding(c->argv[2]);
//调用setGenericCommand函数

    setGenericCommand(c,flags,c->argv[1],c->argv[2],expire,unit,NULL,NULL);
}
//setnxCommand函数

void setnxCommand(redisClient *c) {
    c->argv[2] = tryObjectEncoding(c->argv[2]);
    setGenericCommand(c,REDIS_SET_NX,c->argv[1],c->argv[2],NULL,0,shared.cone,shared.czero);
}
//setexCommand函数

void setexCommand(redisClient *c) {
    c->argv[3] = tryObjectEncoding(c->argv[3]);
    setGenericCommand(c,REDIS_SET_NO_FLAGS,c->argv[1],c->argv[3],c->argv[2],UNIT_SECONDS,NULL,NULL);
}

void psetexCommand(redisClient *c) {
    c->argv[3] = tryObjectEncoding(c->argv[3]);
    setGenericCommand(c,REDIS_SET_NO_FLAGS,c->argv[1],c->argv[3],c->argv[2],UNIT_MILLISECONDS,NULL,NULL);
}


//GET的通用处理函数   http://www.myexception.cn/open-source/1471391.html
int getGenericCommand(redisClient *c) {
    robj *o;

    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL)
        return REDIS_OK;

    if (o->type != REDIS_STRING) {
        addReply(c,shared.wrongtypeerr);
        return REDIS_ERR;
    } else {
        addReplyBulk(c,o);
        return REDIS_OK;
    }
}


//get命令 直接调用getGenericCommand函数

void getCommand(redisClient *c) {
    getGenericCommand(c);
}
/*

   
   

    
    GETSET key value
   
   

   
   


   
   

   
   

    
        将给定key的值设为value，并返回旧值。
   
   

   
   

    
        当key存在但不是字符串类型时，返回一个错误。
   
   


*/
void getsetCommand(redisClient *c) {
    if (getGenericCommand(c) == REDIS_ERR) return;
    c->argv[2] = tryObjectEncoding(c->argv[2]);
//设置值
    setKey(c->db,c->argv[1],c->argv[2]);
    notifyKeyspaceEvent(REDIS_NOTIFY_STRING,"set",c->argv[1],c->db->id);
    server.dirty++;
}

void setrangeCommand(redisClient *c) {
    robj *o;
    long offset;
    sds value = c->argv[3]->ptr;

    if (getLongFromObjectOrReply(c,c->argv[2],&offset,NULL) != REDIS_OK)
        return;

    if (offset < 0) {
        addReplyError(c,"offset is out of range");
        return;
    }

    o = lookupKeyWrite(c->db,c->argv[1]);
    if (o == NULL) {
        /* Return 0 when setting nothing on a non-existing string */
        if (sdslen(value) == 0) {
            addReply(c,shared.czero);
            return;
        }

        /* Return when the resulting string exceeds allowed size */
        if (checkStringLength(c,offset+sdslen(value)) != REDIS_OK)
            return;

        o = createObject(REDIS_STRING,sdsempty());
        dbAdd(c->db,c->argv[1],o);
    } else {
        size_t olen;

        /* Key exists, check type */
        if (checkType(c,o,REDIS_STRING))
            return;

        /* Return existing string length when setting nothing */
        olen = stringObjectLen(o);
        if (sdslen(value) == 0) {
            addReplyLongLong(c,olen);
            return;
        }

        /* Return when the resulting string exceeds allowed size */
        if (checkStringLength(c,offset+sdslen(value)) != REDIS_OK)
            return;

        /* Create a copy when the object is shared or encoded. */
        if (o->refcount != 1 || o->encoding != REDIS_ENCODING_RAW) {
            robj *decoded = getDecodedObject(o);
            o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
            decrRefCount(decoded);
            dbOverwrite(c->db,c->argv[1],o);
        }
    }

    if (sdslen(value) > 0) {
        o->ptr = sdsgrowzero(o->ptr,offset+sdslen(value));
        memcpy((char*)o->ptr+offset,value,sdslen(value));
        signalModifiedKey(c->db,c->argv[1]);
        notifyKeyspaceEvent(REDIS_NOTIFY_STRING,
            "setrange",c->argv[1],c->db->id);
        server.dirty++;
    }
    addReplyLongLong(c,sdslen(o->ptr));
}

void getrangeCommand(redisClient *c) {
    robj *o;
    long start, end;
    char *str, llbuf[32];
    size_t strlen;

    if (getLongFromObjectOrReply(c,c->argv[2],&start,NULL) != REDIS_OK)
        return;
    if (getLongFromObjectOrReply(c,c->argv[3],&end,NULL) != REDIS_OK)
        return;
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptybulk)) == NULL ||
        checkType(c,o,REDIS_STRING)) return;

    if (o->encoding == REDIS_ENCODING_INT) {
        str = llbuf;
        strlen = ll2string(llbuf,sizeof(llbuf),(long)o->ptr);
    } else {
        str = o->ptr;
        strlen = sdslen(str);
    }

    /* Convert negative indexes */
    if (start < 0) start = strlen+start;
    if (end < 0) end = strlen+end;
    if (start < 0) start = 0;
    if (end < 0) end = 0;
    if ((unsigned)end >= strlen) end = strlen-1;

    /* Precondition: end >= 0 && end < strlen, so the only condition where
     * nothing can be returned is: start > end. */
    if (start > end) {
        addReply(c,shared.emptybulk);
    } else {
        addReplyBulkCBuffer(c,(char*)str+start,end-start+1);
    }
}

void mgetCommand(redisClient *c) {
    int j;

    addReplyMultiBulkLen(c,c->argc-1);
    for (j = 1; j < c->argc; j++) {
        robj *o = lookupKeyRead(c->db,c->argv[j]);
        if (o == NULL) {
            addReply(c,shared.nullbulk);
        } else {
            if (o->type != REDIS_STRING) {
                addReply(c,shared.nullbulk);
            } else {
                addReplyBulk(c,o);
            }
        }
    }
}

void msetGenericCommand(redisClient *c, int nx) {
    int j, busykeys = 0;

    if ((c->argc % 2) == 0) {
        addReplyError(c,"wrong number of arguments for MSET");
        return;
    }
    /* Handle the NX flag. The MSETNX semantic is to return zero and don't
     * set nothing at all if at least one already key exists. */
    if (nx) {
        for (j = 1; j < c->argc; j += 2) {
            if (lookupKeyWrite(c->db,c->argv[j]) != NULL) {
                busykeys++;
            }
        }
        if (busykeys) {
            addReply(c, shared.czero);
            return;
        }
    }

    for (j = 1; j < c->argc; j += 2) {
        c->argv[j+1] = tryObjectEncoding(c->argv[j+1]);
        setKey(c->db,c->argv[j],c->argv[j+1]);
        notifyKeyspaceEvent(REDIS_NOTIFY_STRING,"set",c->argv[j],c->db->id);
    }
    server.dirty += (c->argc-1)/2;
    addReply(c, nx ? shared.cone : shared.ok);
}

void msetCommand(redisClient *c) {
    msetGenericCommand(c,0);
}

void msetnxCommand(redisClient *c) {
    msetGenericCommand(c,1);
}

void incrDecrCommand(redisClient *c, long long incr) {
    long long value, oldvalue;
    robj *o, *new;

    o = lookupKeyWrite(c->db,c->argv[1]);
    if (o != NULL && checkType(c,o,REDIS_STRING)) return;
    if (getLongLongFromObjectOrReply(c,o,&value,NULL) != REDIS_OK) return;

    oldvalue = value;
    if ((incr < 0 && oldvalue < 0 && incr < (LLONG_MIN-oldvalue)) ||
        (incr > 0 && oldvalue > 0 && incr > (LLONG_MAX-oldvalue))) {
        addReplyError(c,"increment or decrement would overflow");
        return;
    }
    value += incr;
    new = createStringObjectFromLongLong(value);
    if (o)
        dbOverwrite(c->db,c->argv[1],new);
    else
        dbAdd(c->db,c->argv[1],new);
    signalModifiedKey(c->db,c->argv[1]);
    notifyKeyspaceEvent(REDIS_NOTIFY_STRING,"incrby",c->argv[1],c->db->id);
    server.dirty++;
    addReply(c,shared.colon);
    addReply(c,new);
    addReply(c,shared.crlf);
}

void incrCommand(redisClient *c) {
    incrDecrCommand(c,1);
}

void decrCommand(redisClient *c) {
    incrDecrCommand(c,-1);
}

void incrbyCommand(redisClient *c) {
    long long incr;

    if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != REDIS_OK) return;
    incrDecrCommand(c,incr);
}

void decrbyCommand(redisClient *c) {
    long long incr;

    if (getLongLongFromObjectOrReply(c, c->argv[2], &incr, NULL) != REDIS_OK) return;
    incrDecrCommand(c,-incr);
}

void incrbyfloatCommand(redisClient *c) {
    long double incr, value;
    robj *o, *new, *aux;

    o = lookupKeyWrite(c->db,c->argv[1]);
    if (o != NULL && checkType(c,o,REDIS_STRING)) return;
    if (getLongDoubleFromObjectOrReply(c,o,&value,NULL) != REDIS_OK ||
        getLongDoubleFromObjectOrReply(c,c->argv[2],&incr,NULL) != REDIS_OK)
        return;

    value += incr;
    if (isnan(value) || isinf(value)) {
        addReplyError(c,"increment would produce NaN or Infinity");
        return;
    }
    new = createStringObjectFromLongDouble(value);
    if (o)
        dbOverwrite(c->db,c->argv[1],new);
    else
        dbAdd(c->db,c->argv[1],new);
    signalModifiedKey(c->db,c->argv[1]);
    notifyKeyspaceEvent(REDIS_NOTIFY_STRING,"incrbyfloat",c->argv[1],c->db->id);
    server.dirty++;
    addReplyBulk(c,new);

    /* Always replicate INCRBYFLOAT as a SET command with the final value
     * in order to make sure that differences in float precision or formatting
     * will not create differences in replicas or after an AOF restart. */
    aux = createStringObject("SET",3);
    rewriteClientCommandArgument(c,0,aux);
    decrRefCount(aux);
    rewriteClientCommandArgument(c,2,new);
}

void appendCommand(redisClient *c) {
    size_t totlen;
    robj *o, *append;

    o = lookupKeyWrite(c->db,c->argv[1]);
    if (o == NULL) {
        /* Create the key */
        c->argv[2] = tryObjectEncoding(c->argv[2]);
        dbAdd(c->db,c->argv[1],c->argv[2]);
        incrRefCount(c->argv[2]);
        totlen = stringObjectLen(c->argv[2]);
    } else {
        /* Key exists, check type */
        if (checkType(c,o,REDIS_STRING))
            return;

        /* "append" is an argument, so always an sds */
        append = c->argv[2];
        totlen = stringObjectLen(o)+sdslen(append->ptr);
        if (checkStringLength(c,totlen) != REDIS_OK)
            return;

        /* If the object is shared or encoded, we have to make a copy */
        if (o->refcount != 1 || o->encoding != REDIS_ENCODING_RAW) {
            robj *decoded = getDecodedObject(o);
            o = createStringObject(decoded->ptr, sdslen(decoded->ptr));
            decrRefCount(decoded);
            dbOverwrite(c->db,c->argv[1],o);
        }

        /* Append the value */
        o->ptr = sdscatlen(o->ptr,append->ptr,sdslen(append->ptr));
        totlen = sdslen(o->ptr);
    }
    signalModifiedKey(c->db,c->argv[1]);
    notifyKeyspaceEvent(REDIS_NOTIFY_STRING,"append",c->argv[1],c->db->id);
    server.dirty++;
    addReplyLongLong(c,totlen);
}

void strlenCommand(redisClient *c) {
    robj *o;
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,REDIS_STRING)) return;
    addReplyLongLong(c,stringObjectLen(o));
}









                

        

        

    




    

      

        

            

              
                
                  jianghuihong2012
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
C标准库文件之string.c文件

				
			

			

				

					u011291384的专栏
				

				

					04-13
					
					1063
					
				

			

		

		

			
				
C标准库文件之string.c文件

String.h头文件中定义了一个类型、一个宏以及很多与字符串相关的函数。

定义的类型为:
size_t
 定义的宏为:
NULL，用来初始化指针

定义的函数有：

原型：

#include 

void* memcpy(void* s1, const void* s2, size_t n);

描述：

			
		

	



                

              
                



	

		

			

				
					
redis源码分析之evict.c

				
			

			

				

					小羽毛的博客
				

				

					05-22
					
					763
					
				

			

		

		

			
				
#include "server.h"
#include "bio.h"
#include "atomicvar.h"

/* ----------------------------------------------------------------------------
 * Data structures
 * -------------------------------------...

			
		

	



                


  
              

                


	

		

			

				
					
C++ 如何在终端查看string 的源码？

				
			

			

				

					Bean_Turtle的博客
				

				

					04-07
					
					518
					
				

			

		

		

			
				
1、输入指令find /usr/include/* -name iostream 查看版本号

2、版本号为4.6，然入输入下面代码
vim /usr/include/c++/4.6/bits/basic_string.h



			
		

	





	

		

			

				
					
Redis源码学习（2），t_string.c 学习（一），Set命令实现学习

				
			

			

				

					无痕之意的博客
				

				

					04-14
					
					1077
					
				

			

		

		

			
				
  现在进入Redis源码的学习，首先我们先学习最简单的字符串文件，文件名是t_string.c，该文件在src目录下面，这个文件里面实现了set和get相关一系列命令的方法，今天着重来分析set命令的实现。

			
		

	



		

			
		



	

		

			

				
					
Redis ERR string exceeds maximum allowed size (512MB)错误

				
			

			

				

					fengfeng1229的博客
				

				

					12-26
					
					3981
					
				

			

		

		

			
				
在使用redisTemplate.opsForValue().set(user.getId().toString(), token, Constant.EXPIREDTIME);这样用的时候抛出一个异常ERR string exceeds maximum allowed size (512MB)，告诉我字符串最长为512M，但是我的传入的字符串可能都没到k，我有点懵，最后在stackoverflo...

			
		

	





	

		

			

				
					
redis源码分析与思考（十三）——字符串类型的命令实现(t_string.c)

				
			

			

				

					溯夜，逆流而上
				

				

					10-17
					
					261
					
				

			

		

		

			
				
在对字符串操作的命令中，主要有增加删查该、批处理操作以及编码的转换命令，现在列出对字符串对象操作的主要常用命令

			
		

	





	

		

			

				
					
Redis源码分析

				
			

			

				

					
				

				

					07-25
					
					218
					
				

			

		

		

			
				
Redis的网络模型是基于I/O多路复用程序来实现的。源码中包含四种多路复用函数库epoll、select、evport、kqueue。在程序编译时会根据系统自动选择这四种库其中之一。下面以epoll为例，来分析Redis的I/O模块的源码。
epoll系统调用方法
Redis网络事件处理模块的代码都是围绕epoll那三个系统方法来写的。先把这三个方法弄清楚，后面就不难了。
epfd = epoll_create(1024);
创建epoll实例
参数：表示该 epoll 实例最多可监听的 socket f

			
		

	





	

		

			

				
					
php5.6下的redis扩展（redis/php_redis.dll/php_igbinary.dll）windows环境

				
			

			

				

					04-09
				

			

		

		

			
				
首先，Redis-x64-2.8.2104.zip是Redis服务器的二进制版本，适用于64位操作系统。安装Redis时，你需要解压此文件到一个合适的目录，并启动`redis-server.exe`来运行服务。配置文件`redis.conf`可以自定义Redis实例的...

			
		

	





	

		

			

				
					
redis-3.2.12-2.el7.x86_64.rpm

				
			

			

				

					12-29
				

			

		

		

			
				
官方离线安装包，测试可用。使用rpm -ivh [rpm完整包名] 进行安装

			
		

	





	

		

			

				
					
redis-5.0.10-1.el7.x86_64.rpm

				
			

			

				

					01-09
				

			

		

		

			
				
redis 5.0.10 rpm包

			
		

	





	

		

			

				
					
redis-5.0.12-1.el7.x86_64.rpm

				
			

			

				

					07-19
				

			

		

		

			
				
redis 5.0.12的rpm包

			
		

	





	

		

			

				
					
redis-5.0.14-1.el7.remi.x86-64.rpm安装包(含有部署手册)

					
最新发布

				
			

			

				

					06-26
				

			

		

		

			
				
redis-5.0.14-1.el7.remi.x86_64.rpm安装包(含有部署手册) redis-5.0.14-1.el7.remi.x86_64.rpm安装包(含有部署手册) redis-5.0.14-1.el7.remi.x86_64.rpm安装包(含有部署手册) redis-5.0.14-1.el7.remi.x86_64.rpm...

			
		

	





	

		

			

				
					
Redis源码学习（5），t_string.c 学习（四），学习总结

				
			

			

				

					无痕之意的博客
				

				

					04-20
					
					602
					
				

			

		

		

			
				
  经过几天的学习，我们差不多把t_string.c这个文件的一些方法都学习了一遍，也有了不少的收获，我们今天简单的总结一下我们究竟学到了哪些东西或者了解了哪些东西。
1 方法列表
我们先回顾下这个文件的方法列表
//set相关方法
void setGenericCommand(redisClient *c, int flags, robj *key, robj *val, robj *expire, int unit, robj *ok_reply, robj *abort_reply)
    
voi

			
		

	





	

		

			

				
					
Redis源码剖析--字符串t_string

				
			

			

				

					ZeeCoder 
				

				

					12-20
					
					1495
					
				

			

		

		

			
				
前面一直在分析Redis的底层数据结构，Redis利用这些底层结构设计了它面向用户可见的五种数据结构，字符串、哈希，链表，集合和有序集合，然后用redisObject对这五种结构进行了封装。从这篇博客开始，带你一点点分析五种数据类型常见命令对应的源码实现，慢慢地解开Redis的面纱。字符串概述字符串是Redis中最为常见的数据存储类型，其底层实现是简单动态字符串sds，因此，该字符串类型是二进制安全

			
		

	





	

		

			

				
					
Redis源码分析（九）——字符串类型t_string

				
			

			

				

					艰难困苦如同欢乐，终将成为人生最后的财富
				

				

					10-22
					
					1487
					
				

			

		

		

			
				
在上一分析中已经说明了R

			
		

	





	

		

			

				
					
Redis源码剖析--字符串t_string实现

				
			

			

				

					harleylau的博客
				

				

					05-10
					
					1303
					
				

			

		

		

			
				
介绍完Redis的底层数据结构之后， 介绍我们平时使用Redis的时候可以直接看到五种数据结构：字符串、哈希、链表、集合和有序集合。首先介绍字符串t_string的实现。

			
		

	





	

		

			

				
					
Redis源码学习（3），t_string.c 学习（二），get命令实现学习

				
			

			

				

					无痕之意的博客
				

				

					04-15
					
					790
					
				

			

		

		

			
				
  昨天我们学习了t_string.c代码文件中 get 的相关方法，相信大家已经熟悉不了少 redis 代码的风格和结构，所以今天趁热打铁继续学习剩下的一些方法，由于方法还是比较多的，我们就先学习主要并且我们常用的一个命令 get ，刚好和昨天 set 相对应起来。
1 getGenericCommand
1.1 方法说明
  这是get方法的一个通用方法，get命令通过调用这个方法来获取值
1.2 命令源代码
int getGenericCommand(redisClient *c) {
    rob

			
		

	





	

		

			

				
					
Redis源码剖析和注释（九）--- 字符串命令的实现(t_string)

				
			

			

				

					men_wen的博客
				

				

					04-21
					
					3662
					
				

			

		

		

			
				
Redis 字符串键的实现(t_string)1. 字符串命令介绍redis中的所有字符串命令如下：字符串类型命令详解
  序号
  命令及描述  1
  SET key value：设置指定 key 的值
  2
  GET key： 获取指定 key 的值。
  3
  GETRANGE key start end： 返回 key 中字符串值的子字符
  4
  GETSET key value

			
		

	





	

		

			

				
					
C#邮件接收系统核心代码（接收POP3邮件IMAP邮件）

					
热门推荐

				
			

			

				

					jianghuihong2012的专栏
				

				

					06-10
					
					1万+
					
				

			

		

		

			
				
/*
 * Created by SharpDevelop.
 * User: Administrator
 * Date: 2013/11/18
 * Time: 20:55
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */
using System;
using Sy

			
		

	





	

		

			

				
					
python 连接redis ,r.close 和r.connection_pool.disconnect()无法断开连接

				
			

			

				

					05-30
				

			

		

		

			
				
如果使用 `r.connection_pool.disconnect()` 仍然无法断开与 Redis 数据库的连接，你可以尝试使用 `r.connection_pool.reset()` 方法，该方法会强制断开连接并创建一个新的连接池。示例如下：

```python
import redis

# 连接 Redis
r = redis.StrictRedis(host='localhost', port=6379, db=0)

# 使用 Redis
r.set('key', 'value')
print(r.get('key'))

# 断开连接
r.connection_pool.reset()
```

如果 `r.connection_pool.reset()` 也无法断开连接，那么可能是因为 Redis 数据库设置了超时时间，导致连接一直处于活跃状态。你可以在连接 Redis 数据库时，设置 `socket_timeout` 参数来控制超时时间，示例如下：

```python
import redis

# 连接 Redis
r = redis.StrictRedis(host='localhost', port=6379, db=0, socket_timeout=5)

# 使用 Redis
r.set('key', 'value')
print(r.get('key'))

# 断开连接
r.connection_pool.disconnect()
```

在这个示例中，我们将 `socket_timeout` 参数设置为 5 秒，表示如果连接在 5 秒内没有活动，则自动关闭连接。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值