http://www.web008.net

美高梅163888:Redis

1》Redis概述              

        Redis是一种高级数据库,存储其中的数据可以持久化,而且支持的数据类型很丰富,有字符串,链表,集合和有序集合;支持在服务器端计算集合的             并,交和补集(difference)等,还支持多种排序功能,所以Redis也可以被看成是一个数据结构服务 器;Redis的所有数据都是保存在内存中,然后不定期的           通过异步方式保存到磁盘上(这称为“半持久化模式”);也可以把每一次数据变化都写入到一个append only file(aof)里面(这称为“全持久化模式”)。

2》Redis数据持久化(俗称“数据落地”)

                 是一个支持持久化的内存数据库,也就是说redis需要经常将内存中的数据同步到磁盘来保证持久化;redis支持四种持久化方式一是 Snapshotting(快             照)也是默认方式;二是Append-only file(缩写aof)的方式;三是虚拟内存方式;四是diskstore方式;

            1>Snapshotting

                       快照是默认的持久化方式,这种方式是就是将内存中数据以快照的方式写入到二进制文件中,默认的文件名为dump.rdb。可以通过配置设置自动做快                  照持久化的方式。我们可以配置redis在n秒内如果超过m个key被修改就自动做快照,下面是默认的快照保存配置:

                              save 900 1      #900秒内如果超过1个key被修改,则发起快照保存
          save 300 10      #300秒内容如超过10个key被修改,则发起快照保存
          save 60 10000                 

              快照保存过程:
                    1. redis调用fork函数,有了子进程和父进程,fork() 创建一个新进程,并为它创建新的地址空间;

                   2. 父进程继续处理client请求,子进程负责将内存内容写入到临时文件。由于os的写时复制机制(copy on write)父子进程会共享相同的物理页面,当                       父进程处理写请求时os会为父进程要修改的页面创建副本,而不是写共享的页面。所以子进程的地址空间内的数据是fork时刻整个数据库的一个快                       照;

                  3. 当子进程将快照写入临时文件完毕后,用临时文件替换原来的快照文件,然后子进程退出(fork一个进程入内在也被复制了,即内存会是原来的两                       倍)。              

                        client 也可以使用save或者bgsave命令通知redis做一次快照持久化。save操作是在主线程中保存快照的,由于redis是用一个主线程来处理所                    有 client的请求,这种方式会阻塞所有client请求。所以不推荐使用。另一点需要注意的是,每次快照持久化都是将内存数据完整写入到磁盘一次,并不               是增量的只同步脏数据。如果数据量大或者频繁修改的话,而且写操作比较多,必然会引起大量的磁盘io操作,可能会严重影响性能。

            另外由于快照方式是在一定间隔时间做一次的,所以如果redis意外down掉的话,就会丢失最后一次快照后的所有修改。如果应用要求不能丢失任何修改             的话,可以采用aof持久化方式。

             2> Append-only file

                           aof 比快照方式有更好的持久化性,是由于在使用aof持久化方式时,redis会将每一个收到的写命令都通过write函数追加到文件中(默认是                            appendonly.aof)。当redis重启时会通过重新执行文件中保存的写命令来在内存中重建整个数据库的内容。当然由于os会在内核中缓存 write做的修                        改,所以可能不是立即写到磁盘上。这样aof方式的持久化也还是有可能会丢失部分修改。不过我们可以通过配置文件告诉redis我们想要通过fsync函                    数强制os写入到磁盘的时机。有三种方式如下(默认是:每秒fsync一次):

                              appendonly yes           #启用aof持久化方式
                              # appendfsync always   #每次收到写命令就立即强制写入磁盘,最慢的,但是保证完全的持久化,不推荐使用
                                 appendfsync everysec     #每秒钟强制写入磁盘一次,在性能和持久化方面做了很好的折中,推荐
                              # appendfsync no    #完全依赖os,性能最好,持久化没保证

                         aof 的方式也同时带来了另一个问题。持久化文件会变的越来越大。例如我们调用incr test命令100次,文件中必须保存全部的100条命令,其实                  有99条都是多余的。因为要恢复数据库的状态其实文件中保存一条set test 100就够了。为了压缩aof的持久化文件。redis提供了bgrewriteaof命令。收                  到此命令redis将使用与快照类似的方式将内存中的数据以命令的方式保存到临时文件中,最后替换原来的文件。具体过程如下:

                          1.  redis调用fork ,现在有父子两个进程;
                          2. 子进程根据内存中的数据库快照,往临时文件中写入重建数据库状态的命令;
                          3. 父进程继续处理client请求,除了把写命令写入到原来的aof文件中。同时把收到的写命令缓存起来,这样就能保证如果子进程重写失败的话并                                不会出问题;
                          4. 当子进程把快照内容写入以命令方式写到临时文件中后,子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件;
                          5. 现在父进程可以使用临时文件替换老的aof文件,并重命名,后面收到的写命令也开始往新的aof文件中追加。

                       需要注意到是重写aof文件的操作,并没有读取旧的aof文件,而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件,这点和快照                          有点类似。

               3>虚拟内存方式(desprecated):

                        首先说明:在Redis-2.4后虚拟内存功能已经被deprecated了,原因如下:

          1)slow restart    重启太慢

          2)slow saving    保存数据太慢

          3)slow replication  上面两条导致 replication 太慢

          4)complex code   代码过于复杂

                               redis的虚拟内存与os的虚拟内存不是一码事,但是思路和目的都是相同的。就是暂时把不经常访问的数据从内存交换到磁盘中,从而腾出宝                   贵的内存空间用于其他需要访问的数据。尤其是对于redis这样的内存数据库,内存总是不够用的。除了可以将数据分割到多个redis server外。另外                     的能够提高数据库容量的办法就是使用vm把那些不经常访问的数据交换的磁盘上。如果我们的存储的数据总是有少部分数据被经常访问,大部分数据                   很少被访问,对于网站来说确实总是只有少量用户经常活跃。当少量数据被经常访问时,使用vm不但能提高单台redis server数据库的容量,而且也                     不会对性能造成太多影响。                       

                 redis没有使用os提供的虚拟内存机制而是自己在用户态实现了自己的虚拟内存机制,作者在自己的blog专门解释了其中原因。

                 
                主要的理由有两点:

                          1. os 的虚拟内存是已4k页面为最小单位进行交换的。而redis的大多数对象都远小于4k,所以一个os页面上可能有多个redis对象。另外redis的                                 集合对象类型如list,set可能存在与多个os页面上。最终可能造成只有10%key被经常访问,但是所有os页面都会被os认为是活跃的,这样只                                   有内存真正耗尽时os才会交换页面;
                          2.相比于os的交换方式。redis可以将被交换到磁盘的对象进行压缩,保存到磁盘的对象可以去除指针和对象元数据信息。一般压缩后的对象会比                                内存中的对象小10倍。这样redis的vm会比os vm能少做很多io操作;
                下面是vm相关配置:                               

                             slaveof 192.168.1.1 6379  #指定master的ip和端口

                             vm-enabled yes          #开启vm功能
                             vm-swap-file /tmp/redis.swap   #交换出来的value保存的文件路径/tmp/redis.swap
                             vm-max-memory 1000000  #redis使用的最大内存上限,超过上限后redis开始交换value到磁盘文件中
                             vm-page-size 32        #每个页面的大小32个字节
                             vm-pages 134217728     #最多使用在文件中使用多少页面,交换文件的大小 = vm-page-size * vm-pages
                             vm-max-threads 4       #用于执行value对象换入换出的工作线程数量,0表示不使用工作线程(后面介绍)                         

                redis的vm在设计上为了保证key的查找速度,只会将value交换到swap文件中。所以如果是内存问题是由于太多value很小的key造成的,那么vm并不           能解决。和os一样redis也是按页面来交换对象的。redis规定同一个页面只能保存一个对象。但是一个对象可以保存在多个页面中。在redis使用的内存没超        过vm-max-memory之前是不会交换任何value的。当超过最大内存限制后,redis会选择较老的对象。如果两个对象一样老会优先交换比较大的对象,精确的        公式swappability = age*log(size_in_memory)。对于vm-page-size的设置应该根据自己的应用将页面的大小设置为可以容纳大多数对象的大小。太大了会浪        费磁盘空间,太小了会造成交换文件出现碎片。对于交换文件中的每个页面,redis会在内存中对应一个1bit值来记录页面的空闲状态。所以像上面配置中页         面数量(vm-pages 134217728 )会占用16M内存用来记录页面空闲状态。vm-max-threads表示用做交换任务的线程数量。如果大于0推荐设为服务器的cpu           core的数量。如果是0则交换过程在主线程进行;

                          

       参数配置讨论完后,在来简单介绍下vm是如何工作的:
       当vm-max-threads设为0时(Blocking VM)

      换出:
             主线程定期检查发现内存超出最大上限后,会直接已阻塞的方式,将选中的对象保存到swap文件中,并释放对象占用的内存,此过程会一直重复直到下面            条件满足:
           1.内存使用降到最大限制以下
           2.swap文件满了
           3.几乎全部的对象都被交换到磁盘了
     换入:
              当有client请求value被换出的key时。主线程会以阻塞的方式从文件中加载对应的value对象,加载时此时会阻塞所有client。然后处理client的请求
       当vm-max-threads大于0(Threaded VM)
换出:
         当主线程检测到使用内存超过最大上限,会将选中的要交换的对象信息放到一个队列中交由工作线程后台处理,主线程会继续处理client请求。
换入:
         如果有client请求的key被换出了,主线程先阻塞发出命令的client,然后将加载对象的信息放到一个队列中,让工作线程去加载。加载完毕后工作线程通知主          线程。主线程再执行client的命令。这种方式只阻塞请求value被换出key的client;

       总的来说blocking vm的方式总的性能会好一些,因为不需要线程同步,创建线程和恢复被阻塞的client等开销。但是也相应的牺牲了响应性。threaded vm的          方式主线程不会阻塞在磁盘io上,所以响应性更好。如果我们的应用不太经常发生换入换出,而且也不太在意有点延迟的话则推荐使用blocking vm的方式。

       关于redis vm的更详细介绍可以参考下面链接:
         
         

           3>diskstore方式                     

                diskstore方式是作者放弃了虚拟内存方式后选择的一种新的实现方式,也就是传统的B-tree的方式。具体细节是:

        1) 读操作,使用read through以及LRU方式。内存中不存在的数据从磁盘拉取并放入内存,内存中放不下的数据采用LRU淘汰。

     2) 写操作,采用另外spawn一个线程单独处理,写线程通常是异步的,当然也可以 把cache-flush-delay配置设成0,Redis尽量保证即时写入。但是在                       很多场合延迟写会有更好的性能,比如一些计数器用Redis存储, 在短时间如果某个计数反复被修改,Redis只需要将最终的结果写入磁盘。这种                         做法作者叫per key persistence。由于写入会按key合并,因此和snapshot还是有差异,disk store并不能保证时间一致性。

                     由于写操作是单线程,即使cache-flush-delay设成0,多个client同时写则需要排队等待,如果队列容量超过cache-max-memory Redis设计会进入等                      待状态,造成调用方卡住;

                     Google Group上有热心网友迅速完成了压力测试,当内存用完之后,set每秒处理速度从25k下降到10k再到后来几乎卡住。 虽然通过增加cache-                          flush-delay可以提高相同key重复写入性能;通过增加cache-max-memory可以应对临时峰值写入。但是diskstore写入瓶颈最终还是在IO。

                3) rdb 和新 diskstore 格式关系
            rdb是传统Redis内存方式的存储格式,diskstore是另外一种格式,那两者关系如何?

            ·通过BGSAVE可以随时将diskstore格式另存为rdb格式,而且rdb格式还用于Redis复制以及不同存储方式之间的中间格式;

      · 通过工具可以将rdb格式转换成diskstore格式;

                        当然,diskstore原 理很美好,但是目前还处于alpha版本,也只是一个简单demo,diskstore.c加上注释只有300行,实现的方法就是将每个value                       作为一 个独立文件保存,文件名是key的hash值。因此diskstore需要将来有一个更高效稳定的实现才能用于生产环境。但由于有清晰的接口设 计,                      diskstore.c也很容易换成一种B-Tree的实现。很多开发者也在积极探讨使用bdb或者innodb来替换默认diskstore.c的 可行性。

           

    下面介绍一下Diskstore的算法。

       其实DiskStore类 似于Hash算法,首先通过SHA1算法把Key转化成一个40个字符的Hash值,然后把Hash值的前两位作为一级目录,然后把Hash             值的三四位作 为二级目录,最后把Hash值作为文件名,类似于“/0b/ee/0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33” 形式。算法如下:

    dsKeyToPath(key):

    char path[1024];

    char *hashKey = sha1(key);

    path[0] = hashKey[0];

    path[1] = hashKey[1];

    path[2] = '/';

    path[3] = hashKey[2];

    path[4] = hashKey[3];

    path[5] = '/';

    memcpy(path + 6, hashKey, 40);

    return path;

 

  存储算法(如key == apple):

    dsSet(key, value, expireTime):

      // d0be2dc421be4fcd0172e5afceea3970e2f3d940

    char *hashKey = sha1(key);

    // d0/be/d0be2dc421be4fcd0172e5afceea3970e2f3d940

    char *path = dsKeyToPath(hashKey);

    FILE *fp = fopen(path, "w");

    rdbSaveKeyValuePair(fp, key, value, expireTime);

    fclose(fp)

 

    获取算法:

    dsGet(key):

    char *hashKey = sha1(key);

    char *path = dsKeyToPath(hashKey);

    FILE *fp = fopen(path, "r");

    robj *val = rdbLoadObject(fp);

    return val;

 3》Redis安装:

            1>软件安装:                  

      # cd /data/soft/

      # tar xf redis-2.4.15.tar.gz -C tmp/

      # cd tmp/redis-2.4.15/

      #make PREFIX=/usr/local/services/redis-2.4.15 >/dev/null

      #make PREFIX=/usr/local/services/redis-2.4.15 install >/dev/null

      #ln -s /usr/local/services/redis-2.4.15/bin/ /usr/local/services/redis/

      会在当前目录下生成可执行文件,分别是redis-server、redis-cli、redis-benchmark、redis-stat,它们的作用如下:

                     

·                      redis-server:Redis服务器的daemon启动程序

·                      redis-cli:Redis命令行操作工具。当然,你也可以用telnet根据其纯文本协议来操作

·                      redis-benchmark:Redis性能测试工具,测试Redis在你的系统及你的配置下的读写性能

·                      redis-stat:Redis状态检测工具,可以检测Redis当前状态参数及延迟状况 

            2>调整overcommit_memory参数                                

                      如果内存情况比较紧张的话,需要设定内核参数overcommit_memory,指定内核针对内存分配的策略,其值可以是0、1、2。
      0,表示内核将检查是否有足够的可用内存供应用进程使用;如果有足够的可用内存,内存申请允许;否则,内存申请失败,并把错误返回给应用进程。
    1,表示内核允许分配所有的物理内存,而不管当前的内存状态如何。
    2,表示内核允许分配超过所有物理内存和交换空间总和的内存
      Redis在dump数据的时候,会fork出一个子进程,理论上child进程所占用的内存和parent是一样的,比如parent占用的内存为 8G,这个时候也要同                  样分配8G的内存给child, 如果内存无法负担,往往会造成redis服务器的down机或者IO负载过高,效率下降。所以这里比较优化的内存分配策略应该设                  置为 1(表示内核允许分配所有的物理内存,而不管当前的内存状态如何)。

    设置方式有两种,需确定当前用户的权限活使用root用户修改:                     

      1:重设文件 # echo 1 > /proc/sys/vm/overcommit_memory(默认为0)

      2: # echo "vm.overcommit_memory=1" >> /etc/sysctl.conf

        # /sbin/sysctl -p

            3>拷贝配置文件                        

         #mkdir /usr/local/services/redis-2.4.15/etc

      # cd /soft/redis/redis-2.4.15

        # cp redis.conf /usr/local/services/redis-2.4.15/etc/

        直接在 安装目录下创建conf文件夹,然后创建一个配置文件。

       /usr/local/redis-2.1.15/conf

            4>Redis配置文件:                        

     # mkdir –p /data/redis/redis_db

    #mkdir –p /data/redis/redis_dump

     daemonize yes

    pidfile /data/redis/redis_db/redis.pid

    port 6379

    timeout 300

    loglevel debug

    logfile stdout

    databases 16

    save 900 1

    save 300 10

    save 60 10000

    rdbcompression yes

    dbfilename dump.rdb

    dir /data/redis/redis_dump

    slave-serve-stale-data yes

    appendonly no

    appendfsync everysec

    no-appendfsync-on-rewrite no

    auto-aof-rewrite-percentage 100

    auto-aof-rewrite-min-size 64mb

    slowlog-log-slower-than 10000

    slowlog-max-len 128

    vm-enabled no

    vm-swap-file /data/redis/redis_db/redis.swap

    vm-max-memory 0

    vm-page-size 32

    vm-pages 134217728

    vm-max-threads 4

    hash-max-zipmap-entries 512

    hash-max-zipmap-value 64

    list-max-ziplist-entries 512

    list-max-ziplist-value 64

    set-max-intset-entries 512

    zset-max-ziplist-entries 128

    zset-max-ziplist-value 64

    activerehashing yes

    bind 127.0.0.1             

  配置文件说明

    daemonize yes # Redis默认不是以守护进程的方式运行,可以通过该配置项修改,使用yes启用守护进程

    pidfile /data/redis/redis_db/redis.pid #当Redis以守护进程方式运行时,Redis默认会把pid写入/var/run/redis.pid文件,可以通过pidfile指定

    port 6379 #指定Redis监听端口,默认端口为6379,作者在自己的一篇博文中解释了为什么选用6379作为默认端口,因为6379在手机按键上MERZ对应                                  的号码,而MERZ取自意大利歌女Alessia Merz的名字

              timeout 300  #当客户端闲置多长时间后关闭连接,如果指定为0,表示关闭该功能

              loglevel debug #指定日志记录级别,Redis总共支持四个级别:debug、verbose、notice、warning,默认为verbose

              logfile stdout  #日志记录方式,默认为标准输出,如果配置Redis为守护进程方式运行,而这里又配置为日志记录方式为标准输出,则日志将会发送                                             给/dev/null

             databases 16 #设置数据库的数量,默认数据库为0,可以使用SELECT <dbid>命令在连接上指定数据库id

             #指定在多长时间内,有多少次更新操作,就将数据同步到数据文件,可以多个条件配合Redis默认配置文件中提供了三个条件

     save 900 1

    save 300 10

    save 60 10000

   #指定存储至本地数据库时是否压缩数据,默认为yes,Redis采用LZF压缩,如果为了节省CPU时间,可以关闭该选项,但会导致数据库文件变的巨大

    rdbcompression yes

   #指定本地数据库文件名,默认值为dump.rdb

    dbfilename dump.rdb

     #指定本地数据库存放目录

    dir /data/redis/redis_dump

        #设置当本机为slav服务时,设置master服务的IP地址及端口,在Redis启动时,它会自动从master进行数据同步

    slave-serve-stale-data yes

  #. 指定是否在每次更新操作后进行日志记录,Redis在默认情况下是异步的把数据写入磁盘,如果不开启,可能会在断电时导致一段时间内的数据丢失。因               为 redis本身同步数据文件是按上面save条件来同步的,所以有的数据会在一段时间内只存在于内存中。默认为no

    appendonly no

  #指定更新日志条件,共有3个可选值: 
    no:表示等操作系统进行数据缓存同步到磁盘(快) 
    always:表示每次更新操作后手动调用fsync()将数据写到磁盘(慢,安全)
    everysec:表示每秒同步一次(折衷,默认值)

    appendfsync everysec

  #当AOF文件增长到一定大小的时候Redis能够调用 BGREWRITEAOF 对日志文件进行重写

    no-appendfsync-on-rewrite no

    auto-aof-rewrite-percentage 100

    auto-aof-rewrite-min-size 64mb

  #注意制定一个负数将关闭慢日志,而设置为0将强制每个命令都会记录

    slowlog-log-slower-than 10000

    slowlog-max-len 128

    #指定是否启用虚拟内存机制,默认值为no,简单的介绍一下,VM机制将数据分页存放,由Redis将访问量较少的页即冷数据swap到磁盘上,访问多的页面            由磁盘自动换出到内存中(在后面的文章我会仔细分析Redis的VM机制)

    vm-enabled no

   #虚拟内存文件路径,默认值为/tmp/redis.swap,不可多个Redis实例共享

      vm-swap-file /data/redis/redis_db/redis.swap #交换文件

  #将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-           max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0

    vm-max-memory 0

   #Redis swap文件分成了很多的page,一个对象可以保存在多个page上面,但一个page上不能被多个对象共享,vm-page-size是要根据存储的 数据大小来设        定的,作者建议如果存储很多小对象,page大小最好设置为32或者64bytes;如果存储很大大对象,则可以使用更大的page,如果不 确定,就使用默认值

    vm-page-size 32

  #设置swap文件中的page数量,由于页表(一种表示页面空闲或使用的bitmap)是在放在内存中的,,在磁盘上每8个pages将消耗1byte的内存

    vm-pages 134217728

  #设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的,可能会造成比较长时间的延迟。默认值为4

    vm-max-threads 4

  #指定在超过一定的数量或者最大的元素超过某一临界值时,采用一种特殊的哈希算法

       hash-max-zipmap-entries 512

    hash-max-zipmap-value 64

  #list数据类型节点值大小小于多少字节会采用紧凑存储格式。

    list-max-ziplist-entries 512

    list-max-ziplist-value 64

  #set数据类型内部数据如果全部是数值型,且包含多少节点以下会采用紧凑格式存储。

    set-max-intset-entries 512

  #zsort数据类型节点值大小小于多少字节会采用紧凑存储格式。

    zset-max-ziplist-entries 128

    zset-max-ziplist-value 64

  #指定是否激活重置哈希,默认为开启

    activerehashing yes

  #绑定的主机地址

    bind 127.0.0.1

4》启动Redis服务           **

  # redis-server conf/redis.conf

  # redis-cli shutdown 停止Redis 关闭服务

  # redis-cli -p 6380 shutdown 如果非默认端口,可指定端口:

 5》测试Redis           **

  # ls /data/redis/redis_dump/  看看是否有文件。没有?正常。我们写入数据进去

  # telnet localhost  6379   

    Trying ::1...

    telnet: connect to address ::1: Connection refused

    Trying 127.0.0.1...

    Connected to localhost.

    Escape character is '^]'.

    get mykey

    $-1

    set foo 3

    +OK

    get foo

    $1

    3

    quit

    +OK

    Connection closed by foreign host.

   # ls /data/redis/redis_dump/  在此尝试看看。。

  Redis集群缓存机制很好的地解决了IO密集型和内存密集型的运用。

 

郑重声明:本文版权归美高梅163888所有,转载文章仅为传播更多信息之目的,如作者信息标记有误,请第一时间联系我们修改或删除,多谢。