{"id":327,"date":"2012-07-16T20:59:10","date_gmt":"2012-07-16T12:59:10","guid":{"rendered":"http:\/\/www.royalwzy.com\/?p=327"},"modified":"2014-04-11T14:30:17","modified_gmt":"2014-04-11T06:30:17","slug":"redis%e5%ad%a6%e4%b9%a001-%e5%9c%a8linux%e4%b8%8b%e5%ae%89%e8%a3%85redis-v2-6-13","status":"publish","type":"post","link":"http:\/\/www.royalwzy.com\/?p=327","title":{"rendered":"Redis\u5b66\u4e6001–\u5728Linux\u4e0b\u5b89\u88c5Redis v2.6.13"},"content":{"rendered":"
\n
\u5b89\u88c5Redis<\/div>\n
\n
    \n
  1. Redis\u7684\u4ecb\u7ecd:\n
      \n
    1. redis\u662f\u4e00\u4e2a\u5f00\u6e90\u7684key-value\u6570\u636e\u5e93,\u5b83\u53c8\u7ecf\u5e38\u88ab\u8ba4\u4e3a\u662f\u4e00\u4e2a\u6570\u636e\u7ed3\u6784\u670d\u52a1\u5668,\u56e0\u4e3a\u5b83\u7684value\u4e0d\u4ec5\u5305\u62ec\u57fa\u672c\u7684string\u7c7b\u578b\u8fd8\u6709list,set,sorted set\u548chash\u7c7b\u578b,\u5f53\u7136\u8fd9\u4e9b\u7c7b\u578b\u7684\u5143\u7d20\u4e5f\u90fd\u662fstring\u7c7b\u578b,\u4e5f\u5c31\u662f\u8bf4list,set\u8fd9\u4e9b\u96c6\u5408\u7c7b\u578b\u4e5f\u53ea\u80fd\u5305\u542bstring\u7c7b\u578b;<\/li>\n
    2. \u53ef\u4ee5\u5728\u8fd9\u4e9b\u7c7b\u578b\u4e0a\u505a\u5f88\u591a\u539f\u5b50\u6027\u7684\u64cd\u4f5c,\u6bd4\u5982\u5bf9\u4e00\u4e2a\u5b57\u7b26value\u8ffd\u52a0\u5b57\u7b26\u4e32(APPEND\u547d\u4ee4),\u52a0\u52a0\u6216\u8005\u51cf\u51cf\u4e00\u4e2a\u6570\u5b57\u5b57\u7b26\u4e32(INCR\u547d\u4ee4,\u5f53\u7136\u662f\u6309\u6574\u6570\u5904\u7406\u7684),\u53ef\u4ee5\u5bf9list\u7c7b\u578b\u8fdb\u884cpush,\u6216\u8005pop\u5143\u7d20\u64cd\u4f5c(\u53ef\u4ee5\u6a21\u62df\u6808\u548c\u961f\u5217),\u5bf9\u4e8eset\u7c7b\u578b\u53ef\u4ee5\u8fdb\u884c\u4e00\u4e9b\u96c6\u5408\u76f8\u5173\u64cd\u4f5c(intersection,union,difference);<\/li>\n
    3. memcache\u4e5f\u6709\u7c7b\u4f3c\u4e0e++,–\u7684\u547d\u4ee4,\u4e0d\u8fc7memcache\u7684value\u53ea\u5305\u62ecstring\u7c7b\u578b,\u8fdc\u6ca1\u6709redis\u7684value\u7c7b\u578b\u4e30\u5bcc;<\/li>\n
    4. \u548cmemcahe\u4e00\u6837\u4e3a\u4e86\u6027\u80fd,redis\u7684\u6570\u636e\u901a\u5e38\u90fd\u662f\u653e\u5230\u5185\u5b58\u4e2d\u7684,\u5f53\u7136redis\u53ef\u4ee5\u6bcf\u95f4\u9694\u4e00\u5b9a\u65f6\u95f4\u5c06\u5185\u5b58\u4e2d\u6570\u636e\u5199\u5165\u5230\u78c1\u76d8\u4ee5\u9632\u6b62\u6570\u636e\u4e22\u5931;<\/li>\n
    5. redis\u4e5f\u652f\u6301\u4e3b\u4ece\u590d\u5236\u673a\u5236(master-slave replication),redis\u7684\u5176\u5b83\u7279\u6027\u5305\u62ec\u7b80\u5355\u7684\u4e8b\u52a1\u652f\u6301\u548c\u53d1\u5e03\u8ba2\u9605(pub\/sub)\u901a\u9053\u529f\u80fd,\u800c\u4e14redis\u914d\u7f6e\u7ba1\u7406\u975e\u5e38\u7b80\u5355,\u8fd8\u6709\u5404\u79cd\u8bed\u8a00\u7248\u672c\u7684\u5f00\u6e90\u5ba2\u6237\u7aef\u7c7b\u5e93;<\/li>\n<\/ol>\n<\/li>\n
    6. key-list\u7c7b\u578b\u5185\u5b58\u6570\u636e\u5f15\u64ce:\n
        \n
      1. \u4e92\u8054\u7f51\u6570\u636e\u76ee\u524d\u57fa\u672c\u4f7f\u7528\u4e24\u79cd\u65b9\u5f0f\u6765\u5b58\u50a8,\u5173\u7cfb\u6570\u636e\u5e93\u6216\u8005key value,\u4f46\u662f\u8fd9\u4e9b\u4e92\u8054\u7f51\u4e1a\u52a1\u672c\u8eab\u5e76\u4e0d\u5c5e\u4e8e\u8fd9\u4e24\u79cd\u6570\u636e\u7c7b\u578b,\u6bd4\u5982\u7528\u6237\u5728\u793e\u4f1a\u5316\u5e73\u53f0\u4e2d\u7684\u5173\u7cfb,\u5b83\u662f\u4e00\u4e2alist,\u5982\u679c\u8981\u7528\u5173\u7cfb\u6570\u636e\u5e93\u5b58\u50a8\u5c31\u9700\u8981\u8f6c\u6362\u6210\u4e00\u79cd\u591a\u884c\u8bb0\u5f55\u7684\u5f62\u5f0f,\u8fd9\u79cd\u5f62\u5f0f\u5b58\u5728\u5f88\u591a\u5197\u4f59\u6570\u636e,\u6bcf\u4e00\u884c\u9700\u8981\u5b58\u50a8\u4e00\u4e9b\u91cd\u590d\u4fe1\u606f;\u5982\u679c\u7528key value\u5b58\u50a8\u5219\u4fee\u6539\u548c\u5220\u9664\u6bd4\u8f83\u9ebb\u70e6,\u9700\u8981\u5c06\u5168\u90e8\u6570\u636e\u8bfb\u51fa\u518d\u5199\u5165; — by timyang@weibo.com<\/li>\n
      2. \u5982\u679c\u7528key-value\u4e2d\u7684value\u5b58\u50a8list,\u53ea\u80fd\u5b9e\u73b0\u6700\u7b80\u5355\u7684\u5217\u8868\u529f\u80fd(\u6309\u7167id\u6216\u65f6\u95f4\u5148\u540e\u6392\u5e8f,\u4f8b\u5982\u4f7f\u7528memcache\u7684append\u6216prepend\u534f\u8bae),\u5176\u4ed6list\u64cd\u4f5c\u53ea\u80fd\u9760\u5ba2\u6237\u7aef\u64cd\u4f5c,\u6027\u80fd\u5f88\u5dee,\u5982\u679c\u6570\u636e\u91cf\u8f83\u5927,\u64cd\u4f5c\u65f6\u95f4\u662f\u65e0\u6cd5\u63a5\u53d7\u7684,\u5e76\u53d1\u4e5f\u4f1a\u9047\u5230\u5de8\u5927\u6311\u6218);<\/li>\n
      3. key-list\u7cfb\u7edfkey\u5bf9\u5e94\u7684”value”\u662f\u4e00\u4e2alist(eg.set list),\u53ef\u4ee5\u5bf9list\u4e2d\u7684\u5355\u4e2aitem\u8fdb\u884c\u64cd\u4f5c,\u7406\u60f3\u7684key-list\u9700\u8981\u5982\u4e0b\u7279\u70b9:\n
          \n
        1. list\u53ef\u4ee5\u662f\u6d77\u91cf\u7684,\u4e14\u64cd\u4f5c\u6027\u80fd\u9ad8\u6548;<\/li>\n
        2. list\u662f\u53ef\u4ee5\u662f\u6709\u5e8f\u7684,\u4e14\u53ef\u52a8\u6001\u8c03\u6574\u987a\u5e8f;<\/li>\n<\/ol>\n<\/li>\n
        3. \u4f7f\u7528\u573a\u666f:\n
            \n
          1. \u8bba\u575b\u4e2d\u7684\u4e3b\u9898\u5217\u8868,\u56de\u590d\u5217\u8868;<\/li>\n
          2. \u5fae\u535a\u4e2d\u7684\u7528\u6237\u5173\u6ce8\u5217\u8868,\u7528\u6237feed\u5217\u8868,\u7528\u6237\u5173\u6ce8feed\u5217\u8868;<\/li>\n
          3. \u6700\u8fd1\u8bbf\u95ee\u5217\u8868;<\/li>\n
          4. \u96c6\u5408\u64cd\u4f5c:\u6c42\u4ea4\u96c6,\u5e76\u96c6,\u5dee\u96c6(sdiff\/sinter\/sunion);<\/li>\n
          5. \u597d\u53cb\u63a8\u8350;<\/li>\n
          6. \u6392\u884c\u699c;<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
          7. \u4e0b\u8f7d:\n
              \n
            1. \u5b98\u65b9\u5730\u5740:\u00a0http:\/\/redis.io\/<\/a>;<\/li>\n
            2. \u4e0b\u8f7d\u5730\u5740:\u00a0http:\/\/redis.io\/download<\/a>;<\/li>\n
            3. \u6587\u6863\u5730\u5740:\u00a0http:\/\/redis.io\/documentation<\/a>;<\/li>\n
            4. \u4f5c\u8005blog:\u00a0http:\/\/oldblog.antirez.com\/<\/a>;<\/li>\n<\/ol>\n<\/li>\n
            5. \u5b89\u88c5:\n
                \n
              1. \u89e3\u538b\u7f29\u5230\/usr\/local\u76ee\u5f55\u4e0b:tar -zxvf \/tools\/redis-2.6.13.tar.gz -C \/usr\/local\/; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\"\"<\/li>\n
              2. \u7f16\u8bd1:cd \/usr\/local\/redis-2.6.13\/;make; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0\"\"<\/li>\n
              3. \u5b89\u88c5\u65f6\u62a5\u9519:undefined reference to `__sync_add_and_fetch_4′; \u00a0\"\"<\/li>\n
              4. \u662f\u56e0\u4e3aCPU\u4fe1\u606f\u5224\u65ad\u5931\u8bef\u5f15\u8d77\u7684,\u6240\u4ee5\u9700\u8981\u786e\u5b9aCPU\u7684\u4fe1\u606f,\u7136\u540e\u628aCPU\u7684\u4fe1\u606f\u8bbe\u7f6e\u5230\u73af\u5883\u53d8\u91cf\u4e2d,\u6e05\u9664\u65e7\u7684\u7f16\u8bd1\u6587\u4ef6,\u6700\u540e\u91cd\u65b0\u7f16\u8bd1\u5373\u53ef:uname -a(uname -m);export CFLAGS=-march=i686;cd \/usr\/local\/redis-2.6.13\/;make distclean;make; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\"\"<\/li>\n
              5. \u5982\u679c\u9700\u8981\u8fd0\u884cmake-test\u7684\u8bdd\u9700\u8981\u5b89\u88c58.5\u7248\u672c\u4ee5\u4e0a\u7684tcl;<\/li>\n
              6. \u6b64\u65f6\u5c31\u4f1a\u5728src\u76ee\u5f55\u4e0b\u51fa\u73b0redis-server\u7684\u670d\u52a1\u7aef\u548credis-cli\u5ba2\u6237\u7aef,\u4e3a\u4e86\u65b9\u4fbf\u4f7f\u7528\u53ef\u4ee5\u5206\u522b\u521b\u5efa\u8f6f\u8fde\u63a5:ln -s \/usr\/local\/redis-2.6.13\/src\/redis-server \/usr\/local\/redis-2.6.13\/src\/redisd;ln -s \/usr\/local\/redis-2.6.13\/src\/redis-cli \/usr\/local\/redis-2.6.13\/src\/redis; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0\"\"<\/li>\n
              7. \u6dfb\u52a0PATH\u53d8\u91cf:PATH=$PATH:\/usr\/local\/redis-2.6.13\/src; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\"\"<\/li>\n
              8. \u542f\u52a8\u670d\u52a1\u7aef:\n
                  \n
                1. \u9ed8\u8ba4\u914d\u7f6e\u542f\u52a8:redisd;<\/li>\n
                2. \u4f7f\u7528\u81ea\u5df1\u7684\u914d\u7f6e\u6587\u4ef6\u542f\u52a8:redisd \/etc\/redis.conf;<\/li>\n
                3. \u5728\u540e\u53f0\u8fd0\u884c:redisd \/etc\/redis.conf &; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0\"\"<\/li>\n<\/ol>\n<\/li>\n
                4. \u542f\u52a8\u5ba2\u6237\u7aef:redis; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\"\"\"\"<\/li>\n<\/ol>\n<\/li>\n
                5. \u9a71\u52a8\u4e0b\u8f7d:\n
                    \n
                  1. \u5b98\u7f51\u63d0\u4f9b\u7684\u652f\u6301\u8bed\u8a00\u7684\u4e0b\u8f7d\u5730\u5740:\u00a0http:\/\/redis.io\/clients<\/a>;<\/li>\n
                  2. Jedis\u7684github\u5730\u5740:https:\/\/github.com\/xetorthio\/jedis<\/a>;<\/li>\n
                  3. jar\u5305\u4e0b\u8f7d\u5730\u5740:https:\/\/github.com\/xetorthio\/jedis\/downloads<\/a>;<\/li>\n
                  4. \u63d0\u4f9b\u7684\u65b9\u6cd5:\n
                      \n
                    1. Sorting<\/li>\n
                    2. Connection handling<\/li>\n
                    3. Commands operating on any kind of values<\/li>\n
                    4. Commands operating on string values<\/li>\n
                    5. Commands operating on hashes<\/li>\n
                    6. Commands operating on lists<\/li>\n
                    7. Commands operating on sets<\/li>\n
                    8. Commands operating on sorted sets<\/li>\n
                    9. Transactions<\/li>\n
                    10. Pipelining<\/li>\n
                    11. Publish\/Subscribe<\/li>\n
                    12. Persistence control commands<\/li>\n
                    13. Remote server control commands<\/li>\n
                    14. Connection pooling<\/li>\n
                    15. Sharding (MD5, MurmureHash)<\/li>\n
                    16. Key-tags for sharding<\/li>\n
                    17. Sharding with pipelining<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
                    18. \u914d\u7f6e\u6587\u4ef6;<\/li>\n<\/ol>\n<\/div>\n
                      \n
                      # Redis configuration file example<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Note on units: when memory size is needed, it is possible to specify<\/span><\/div>\n
                      # it in the usual form of 1k 5GB 4M and so forth:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # 1k => 1000 bytes<\/span><\/div>\n
                      # 1kb => 1024 bytes<\/span><\/div>\n
                      # 1m => 1000000 bytes<\/span><\/div>\n
                      # 1mb => 1024*1024 bytes<\/span><\/div>\n
                      # 1g => 1000000000 bytes<\/span><\/div>\n
                      # 1gb => 1024*1024*1024 bytes<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # units are case insensitive so 1GB 1Gb 1gB are all the same.<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # By default Redis does not run as a daemon. Use ‘yes’ if you need it.<\/span><\/div>\n
                      # Note that Redis will write a pid file in \/var\/run\/redis.pid when daemonized.<\/span><\/div>\n
                      daemonize yes<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # When running daemonized, Redis writes a pid file in \/var\/run\/redis.pid by<\/span><\/div>\n
                      # default. You can specify a custom pid file location here.<\/span><\/div>\n
                      pidfile \/var\/run\/redis.pid<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Accept connections on the specified port, default is 6379.<\/span><\/div>\n
                      # If port 0 is specified Redis will not listen on a TCP socket.<\/span><\/div>\n
                      port 6379<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # If you want you can bind a single interface, if the bind option is not<\/span><\/div>\n
                      # specified all the interfaces will listen for incoming connections.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # bind 127.0.0.1<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Specify the path for the unix socket that will be used to listen for<\/span><\/div>\n
                      # incoming connections. There is no default, so Redis will not listen<\/span><\/div>\n
                      # on a unix socket when not specified.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # unixsocket \/tmp\/redis.sock<\/span><\/div>\n
                      # unixsocketperm 755<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Close the connection after a client is idle for N seconds (0 to disable)<\/span><\/div>\n
                      timeout 0<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # TCP keepalive.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence<\/span><\/div>\n
                      # of communication. This is useful for two reasons:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # 1) Detect dead peers.<\/span><\/div>\n
                      # 2) Take the connection alive from the point of view of network<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0 equipment in the middle.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # On Linux, the specified value (in seconds) is the period used to send ACKs.<\/span><\/div>\n
                      # Note that to close the connection the double of the time is needed.<\/span><\/div>\n
                      # On other kernels the period depends on the kernel configuration.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # A reasonable value for this option is 60 seconds.<\/span><\/div>\n
                      tcp-keepalive 0<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Specify the server verbosity level.<\/span><\/div>\n
                      # This can be one of:<\/span><\/div>\n
                      # debug (a lot of information, useful for development\/testing)<\/span><\/div>\n
                      # verbose (many rarely useful info, but not a mess like the debug level)<\/span><\/div>\n
                      # notice (moderately verbose, what you want in production probably)<\/span><\/div>\n
                      # warning (only very important \/ critical messages are logged)<\/span><\/div>\n
                      loglevel notice<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Specify the log file name. Also ‘stdout’ can be used to force<\/span><\/div>\n
                      # Redis to log on the standard output. Note that if you use standard<\/span><\/div>\n
                      # output for logging but daemonize, logs will be sent to \/dev\/null<\/span><\/div>\n
                      logfile stdout<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # To enable logging to the system logger, just set ‘syslog-enabled’ to yes,<\/span><\/div>\n
                      # and optionally update the other syslog parameters to suit your needs.<\/span><\/div>\n
                      # syslog-enabled no<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Specify the syslog identity.<\/span><\/div>\n
                      # syslog-ident redis<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.<\/span><\/div>\n
                      # syslog-facility local0<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Set the number of databases. The default database is DB 0, you can select<\/span><\/div>\n
                      # a different one on a per-connection basis using SELECT <dbid> where<\/span><\/div>\n
                      # dbid is a number between 0 and ‘databases’-1<\/span><\/div>\n
                      databases 16<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      ################################ SNAPSHOTTING\u00a0 #################################<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Save the DB on disk:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      #\u00a0\u00a0 save <seconds> <changes><\/span><\/div>\n
                      #<\/span><\/div>\n
                      #\u00a0\u00a0 Will save the DB if both the given number of seconds and the given<\/span><\/div>\n
                      #\u00a0\u00a0 number of write operations against the DB occurred.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      #\u00a0\u00a0 In the example below the behaviour will be to save:<\/span><\/div>\n
                      #\u00a0\u00a0 after 900 sec (15 min) if at least 1 key changed<\/span><\/div>\n
                      #\u00a0\u00a0 after 300 sec (5 min) if at least 10 keys changed<\/span><\/div>\n
                      #\u00a0\u00a0 after 60 sec if at least 10000 keys changed<\/span><\/div>\n
                      #<\/span><\/div>\n
                      #\u00a0\u00a0 Note: you can disable saving at all commenting all the “save” lines.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      #\u00a0\u00a0 It is also possible to remove all the previously configured save<\/span><\/div>\n
                      #\u00a0\u00a0 points by adding a save directive with a single empty string argument<\/span><\/div>\n
                      #\u00a0\u00a0 like in the following example:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      #\u00a0\u00a0 save “”<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      #save 900 1<\/span><\/div>\n
                      #save 300 10<\/span><\/div>\n
                      #save 60 10000<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # By default Redis will stop accepting writes if RDB snapshots are enabled<\/span><\/div>\n
                      # (at least one save point) and the latest background save failed.<\/span><\/div>\n
                      # This will make the user aware (in an hard way) that data is not persisting<\/span><\/div>\n
                      # on disk properly, otherwise chances are that no one will notice and some<\/span><\/div>\n
                      # distater will happen.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # If the background saving process will start working again Redis will<\/span><\/div>\n
                      # automatically allow writes again.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # However if you have setup your proper monitoring of the Redis server<\/span><\/div>\n
                      # and persistence, you may want to disable this feature so that Redis will<\/span><\/div>\n
                      # continue to work as usually even if there are problems with disk,<\/span><\/div>\n
                      # permissions, and so forth.<\/span><\/div>\n
                      stop-writes-on-bgsave-error yes<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Compress string objects using LZF when dump .rdb databases?<\/span><\/div>\n
                      # For default that’s set to ‘yes’ as it’s almost always a win.<\/span><\/div>\n
                      # If you want to save some CPU in the saving child set it to ‘no’ but<\/span><\/div>\n
                      # the dataset will likely be bigger if you have compressible values or keys.<\/span><\/div>\n
                      rdbcompression yes<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.<\/span><\/div>\n
                      # This makes the format more resistant to corruption but there is a performance<\/span><\/div>\n
                      # hit to pay (around 10%) when saving and loading RDB files, so you can disable it<\/span><\/div>\n
                      # for maximum performances.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # RDB files created with checksum disabled have a checksum of zero that will<\/span><\/div>\n
                      # tell the loading code to skip the check.<\/span><\/div>\n
                      rdbchecksum yes<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # The filename where to dump the DB<\/span><\/div>\n
                      dbfilename dump.rdb<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # The working directory.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # The DB will be written inside this directory, with the filename specified<\/span><\/div>\n
                      # above using the ‘dbfilename’ configuration directive.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # The Append Only File will also be created inside this directory.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Note that you must specify a directory here, not a file name.<\/span><\/div>\n
                      dir .\/<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      ################################# REPLICATION #################################<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Master-Slave replication. Use slaveof to make a Redis instance a copy of<\/span><\/div>\n
                      # another Redis server. Note that the configuration is local to the slave<\/span><\/div>\n
                      # so for example it is possible to configure the slave to save the DB with a<\/span><\/div>\n
                      # different interval, or to listen to another port, and so on.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # slaveof <masterip> <masterport><\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # If the master is password protected (using the “requirepass” configuration<\/span><\/div>\n
                      # directive below) it is possible to tell the slave to authenticate before<\/span><\/div>\n
                      # starting the replication synchronization process, otherwise the master will<\/span><\/div>\n
                      # refuse the slave request.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # masterauth <master-password><\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # When a slave loses its connection with the master, or when the replication<\/span><\/div>\n
                      # is still in progress, the slave can act in two different ways:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # 1) if slave-serve-stale-data is set to ‘yes’ (the default) the slave will<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0 still reply to client requests, possibly with out of date data, or the<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0 data set may just be empty if this is the first synchronization.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # 2) if slave-serve-stale-data is set to ‘no’ the slave will reply with<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0 an error “SYNC with master in progress” to all the kind of commands<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0 but to INFO and SLAVEOF.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      slave-serve-stale-data yes<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # You can configure a slave instance to accept writes or not. Writing against<\/span><\/div>\n
                      # a slave instance may be useful to store some ephemeral data (because data<\/span><\/div>\n
                      # written on a slave will be easily deleted after resync with the master) but<\/span><\/div>\n
                      # may also cause problems if clients are writing to it because of a<\/span><\/div>\n
                      # misconfiguration.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Since Redis 2.6 by default slaves are read-only.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Note: read only slaves are not designed to be exposed to untrusted clients<\/span><\/div>\n
                      # on the internet. It’s just a protection layer against misuse of the instance.<\/span><\/div>\n
                      # Still a read only slave exports by default all the administrative commands<\/span><\/div>\n
                      # such as CONFIG, DEBUG, and so forth. To a limited extend you can improve<\/span><\/div>\n
                      # security of read only slaves using ‘rename-command’ to shadow all the<\/span><\/div>\n
                      # administrative \/ dangerous commands.<\/span><\/div>\n
                      slave-read-only yes<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Slaves send PINGs to server in a predefined interval. It’s possible to change<\/span><\/div>\n
                      # this interval with the repl_ping_slave_period option. The default value is 10<\/span><\/div>\n
                      # seconds.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # repl-ping-slave-period 10<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # The following option sets a timeout for both Bulk transfer I\/O timeout and<\/span><\/div>\n
                      # master data or ping response timeout. The default value is 60 seconds.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # It is important to make sure that this value is greater than the value<\/span><\/div>\n
                      # specified for repl-ping-slave-period otherwise a timeout will be detected<\/span><\/div>\n
                      # every time there is low traffic between the master and the slave.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # repl-timeout 60<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Disable TCP_NODELAY on the slave socket after SYNC?<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # If you select “yes” Redis will use a smaller number of TCP packets and<\/span><\/div>\n
                      # less bandwidth to send data to slaves. But this can add a delay for<\/span><\/div>\n
                      # the data to appear on the slave side, up to 40 milliseconds with<\/span><\/div>\n
                      # Linux kernels using a default configuration.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # If you select “no” the delay for data to appear on the slave side will<\/span><\/div>\n
                      # be reduced but more bandwidth will be used for replication.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # By default we optimize for low latency, but in very high traffic conditions<\/span><\/div>\n
                      # or when the master and slaves are many hops away, turning this to “yes” may<\/span><\/div>\n
                      # be a good idea.<\/span><\/div>\n
                      repl-disable-tcp-nodelay no<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # The slave priority is an integer number published by Redis in the INFO output.<\/span><\/div>\n
                      # It is used by Redis Sentinel in order to select a slave to promote into a<\/span><\/div>\n
                      # master if the master is no longer working correctly.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # A slave with a low priority number is considered better for promotion, so<\/span><\/div>\n
                      # for instance if there are three slaves with priority 10, 100, 25 Sentinel will<\/span><\/div>\n
                      # pick the one wtih priority 10, that is the lowest.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # However a special priority of 0 marks the slave as not able to perform the<\/span><\/div>\n
                      # role of master, so a slave with priority of 0 will never be selected by<\/span><\/div>\n
                      # Redis Sentinel for promotion.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # By default the priority is 100.<\/span><\/div>\n
                      slave-priority 100<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      ################################## SECURITY ###################################<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Require clients to issue AUTH <PASSWORD> before processing any other<\/span><\/div>\n
                      # commands.\u00a0 This might be useful in environments in which you do not trust<\/span><\/div>\n
                      # others with access to the host running redis-server.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # This should stay commented out for backward compatibility and because most<\/span><\/div>\n
                      # people do not need auth (e.g. they run their own servers).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Warning: since Redis is pretty fast an outside user can try up to<\/span><\/div>\n
                      # 150k passwords per second against a good box. This means that you should<\/span><\/div>\n
                      # use a very strong password otherwise it will be very easy to break.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # requirepass foobared<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Command renaming.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # It is possible to change the name of dangerous commands in a shared<\/span><\/div>\n
                      # environment. For instance the CONFIG command may be renamed into something<\/span><\/div>\n
                      # hard to guess so that it will still be available for internal-use tools<\/span><\/div>\n
                      # but not available for general clients.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Example:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # It is also possible to completely kill a command by renaming it into<\/span><\/div>\n
                      # an empty string:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # rename-command CONFIG “”<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Please note that changing the name of commands that are logged into the<\/span><\/div>\n
                      # AOF file or transmitted to slaves may cause problems.<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      ################################### LIMITS ####################################<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Set the max number of connected clients at the same time. By default<\/span><\/div>\n
                      # this limit is set to 10000 clients, however if the Redis server is not<\/span><\/div>\n
                      # able to configure the process file limit to allow for the specified limit<\/span><\/div>\n
                      # the max number of allowed clients is set to the current file limit<\/span><\/div>\n
                      # minus 32 (as Redis reserves a few file descriptors for internal uses).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Once the limit is reached Redis will close all the new connections sending<\/span><\/div>\n
                      # an error ‘max number of clients reached’.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # maxclients 10000<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Don’t use more memory than the specified amount of bytes.<\/span><\/div>\n
                      # When the memory limit is reached Redis will try to remove keys<\/span><\/div>\n
                      # accordingly to the eviction policy selected (see maxmemmory-policy).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # If Redis can’t remove keys according to the policy, or if the policy is<\/span><\/div>\n
                      # set to ‘noeviction’, Redis will start to reply with errors to commands<\/span><\/div>\n
                      # that would use more memory, like SET, LPUSH, and so on, and will continue<\/span><\/div>\n
                      # to reply to read-only commands like GET.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # This option is usually useful when using Redis as an LRU cache, or to set<\/span><\/div>\n
                      # an hard memory limit for an instance (using the ‘noeviction’ policy).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # WARNING: If you have slaves attached to an instance with maxmemory on,<\/span><\/div>\n
                      # the size of the output buffers needed to feed the slaves are subtracted<\/span><\/div>\n
                      # from the used memory count, so that network problems \/ resyncs will<\/span><\/div>\n
                      # not trigger a loop where keys are evicted, and in turn the output<\/span><\/div>\n
                      # buffer of slaves is full with DELs of keys evicted triggering the deletion<\/span><\/div>\n
                      # of more keys, and so forth until the database is completely emptied.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # In short… if you have slaves attached it is suggested that you set a lower<\/span><\/div>\n
                      # limit for maxmemory so that there is some free RAM on the system for slave<\/span><\/div>\n
                      # output buffers (but this is not needed if the policy is ‘noeviction’).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # maxmemory <bytes><\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory<\/span><\/div>\n
                      # is reached. You can select among five behaviors:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # volatile-lru -> remove the key with an expire set using an LRU algorithm<\/span><\/div>\n
                      # allkeys-lru -> remove any key accordingly to the LRU algorithm<\/span><\/div>\n
                      # volatile-random -> remove a random key with an expire set<\/span><\/div>\n
                      # allkeys-random -> remove a random key, any key<\/span><\/div>\n
                      # volatile-ttl -> remove the key with the nearest expire time (minor TTL)<\/span><\/div>\n
                      # noeviction -> don’t expire at all, just return an error on write operations<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Note: with any of the above policies, Redis will return an error on write<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 operations, when there are not suitable keys for eviction.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 At the date of writing this commands are: set setnx setex append<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby<\/span><\/div>\n
                      #\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 getset mset msetnx exec sort<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # The default is:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # maxmemory-policy volatile-lru<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # LRU and minimal TTL algorithms are not precise algorithms but approximated<\/span><\/div>\n
                      # algorithms (in order to save memory), so you can select as well the sample<\/span><\/div>\n
                      # size to check. For instance for default Redis will check three keys and<\/span><\/div>\n
                      # pick the one that was used less recently, you can change the sample size<\/span><\/div>\n
                      # using the following configuration directive.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # maxmemory-samples 3<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      ############################## APPEND ONLY MODE ###############################<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # By default Redis asynchronously dumps the dataset on disk. This mode is<\/span><\/div>\n
                      # good enough in many applications, but an issue with the Redis process or<\/span><\/div>\n
                      # a power outage may result into a few minutes of writes lost (depending on<\/span><\/div>\n
                      # the configured save points).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # The Append Only File is an alternative persistence mode that provides<\/span><\/div>\n
                      # much better durability. For instance using the default data fsync policy<\/span><\/div>\n
                      # (see later in the config file) Redis can lose just one second of writes in a<\/span><\/div>\n
                      # dramatic event like a server power outage, or a single write if something<\/span><\/div>\n
                      # wrong with the Redis process itself happens, but the operating system is<\/span><\/div>\n
                      # still running correctly.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # AOF and RDB persistence can be enabled at the same time without problems.<\/span><\/div>\n
                      # If the AOF is enabled on startup Redis will load the AOF, that is the file<\/span><\/div>\n
                      # with the better durability guarantees.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Please check http:\/\/redis.io\/topics\/persistence for more information.<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      appendonly yes<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # The name of the append only file (default: “appendonly.aof”)<\/span><\/div>\n
                      # appendfilename appendonly.aof<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # The fsync() call tells the Operating System to actually write data on disk<\/span><\/div>\n
                      # instead to wait for more data in the output buffer. Some OS will really flush<\/span><\/div>\n
                      # data on disk, some other OS will just try to do it ASAP.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Redis supports three different modes:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # no: don’t fsync, just let the OS flush the data when it wants. Faster.<\/span><\/div>\n
                      # always: fsync after every write to the append only log . Slow, Safest.<\/span><\/div>\n
                      # everysec: fsync only one time every second. Compromise.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # The default is “everysec”, as that’s usually the right compromise between<\/span><\/div>\n
                      # speed and data safety. It’s up to you to understand if you can relax this to<\/span><\/div>\n
                      # “no” that will let the operating system flush the output buffer when<\/span><\/div>\n
                      # it wants, for better performances (but if you can live with the idea of<\/span><\/div>\n
                      # some data loss consider the default persistence mode that’s snapshotting),<\/span><\/div>\n
                      # or on the contrary, use “always” that’s very slow but a bit safer than<\/span><\/div>\n
                      # everysec.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # More details please check the following article:<\/span><\/div>\n
                      # http:\/\/antirez.com\/post\/redis-persistence-demystified.html<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # If unsure, use “everysec”.<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # appendfsync always<\/span><\/div>\n
                      appendfsync everysec<\/span><\/div>\n
                      # appendfsync no<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # When the AOF fsync policy is set to always or everysec, and a background<\/span><\/div>\n
                      # saving process (a background save or AOF log background rewriting) is<\/span><\/div>\n
                      # performing a lot of I\/O against the disk, in some Linux configurations<\/span><\/div>\n
                      # Redis may block too long on the fsync() call. Note that there is no fix for<\/span><\/div>\n
                      # this currently, as even performing fsync in a different thread will block<\/span><\/div>\n
                      # our synchronous write(2) call.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # In order to mitigate this problem it’s possible to use the following option<\/span><\/div>\n
                      # that will prevent fsync() from being called in the main process while a<\/span><\/div>\n
                      # BGSAVE or BGREWRITEAOF is in progress.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # This means that while another child is saving, the durability of Redis is<\/span><\/div>\n
                      # the same as “appendfsync none”. In practical terms, this means that it is<\/span><\/div>\n
                      # possible to lose up to 30 seconds of log in the worst scenario (with the<\/span><\/div>\n
                      # default Linux settings).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # If you have latency problems turn this to “yes”. Otherwise leave it as<\/span><\/div>\n
                      # “no” that is the safest pick from the point of view of durability.<\/span><\/div>\n
                      no-appendfsync-on-rewrite no<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Automatic rewrite of the append only file.<\/span><\/div>\n
                      # Redis is able to automatically rewrite the log file implicitly calling<\/span><\/div>\n
                      # BGREWRITEAOF when the AOF log size grows by the specified percentage.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # This is how it works: Redis remembers the size of the AOF file after the<\/span><\/div>\n
                      # latest rewrite (if no rewrite has happened since the restart, the size of<\/span><\/div>\n
                      # the AOF at startup is used).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # This base size is compared to the current size. If the current size is<\/span><\/div>\n
                      # bigger than the specified percentage, the rewrite is triggered. Also<\/span><\/div>\n
                      # you need to specify a minimal size for the AOF file to be rewritten, this<\/span><\/div>\n
                      # is useful to avoid rewriting the AOF file even if the percentage increase<\/span><\/div>\n
                      # is reached but it is still pretty small.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Specify a percentage of zero in order to disable the automatic AOF<\/span><\/div>\n
                      # rewrite feature.<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      auto-aof-rewrite-percentage 100<\/span><\/div>\n
                      auto-aof-rewrite-min-size 64mb<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      ################################ LUA SCRIPTING\u00a0 ###############################<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Max execution time of a Lua script in milliseconds.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # If the maximum execution time is reached Redis will log that a script is<\/span><\/div>\n
                      # still in execution after the maximum allowed time and will start to<\/span><\/div>\n
                      # reply to queries with an error.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # When a long running script exceed the maximum execution time only the<\/span><\/div>\n
                      # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be<\/span><\/div>\n
                      # used to stop a script that did not yet called write commands. The second<\/span><\/div>\n
                      # is the only way to shut down the server in the case a write commands was<\/span><\/div>\n
                      # already issue by the script but the user don’t want to wait for the natural<\/span><\/div>\n
                      # termination of the script.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Set it to 0 or a negative value for unlimited execution without warnings.<\/span><\/div>\n
                      lua-time-limit 5000<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      ################################## SLOW LOG ###################################<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # The Redis Slow Log is a system to log queries that exceeded a specified<\/span><\/div>\n
                      # execution time. The execution time does not include the I\/O operations<\/span><\/div>\n
                      # like talking with the client, sending the reply and so forth,<\/span><\/div>\n
                      # but just the time needed to actually execute the command (this is the only<\/span><\/div>\n
                      # stage of command execution where the thread is blocked and can not serve<\/span><\/div>\n
                      # other requests in the meantime).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # You can configure the slow log with two parameters: one tells Redis<\/span><\/div>\n
                      # what is the execution time, in microseconds, to exceed in order for the<\/span><\/div>\n
                      # command to get logged, and the other parameter is the length of the<\/span><\/div>\n
                      # slow log. When a new command is logged the oldest one is removed from the<\/span><\/div>\n
                      # queue of logged commands.<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # The following time is expressed in microseconds, so 1000000 is equivalent<\/span><\/div>\n
                      # to one second. Note that a negative number disables the slow log, while<\/span><\/div>\n
                      # a value of zero forces the logging of every command.<\/span><\/div>\n
                      slowlog-log-slower-than 10000<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # There is no limit to this length. Just be aware that it will consume memory.<\/span><\/div>\n
                      # You can reclaim memory used by the slow log with SLOWLOG RESET.<\/span><\/div>\n
                      slowlog-max-len 128<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      ############################### ADVANCED CONFIG ###############################<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Hashes are encoded using a memory efficient data structure when they have a<\/span><\/div>\n
                      # small number of entries, and the biggest entry does not exceed a given<\/span><\/div>\n
                      # threshold. These thresholds can be configured using the following directives.<\/span><\/div>\n
                      hash-max-ziplist-entries 512<\/span><\/div>\n
                      hash-max-ziplist-value 64<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Similarly to hashes, small lists are also encoded in a special way in order<\/span><\/div>\n
                      # to save a lot of space. The special representation is only used when<\/span><\/div>\n
                      # you are under the following limits:<\/span><\/div>\n
                      list-max-ziplist-entries 512<\/span><\/div>\n
                      list-max-ziplist-value 64<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Sets have a special encoding in just one case: when a set is composed<\/span><\/div>\n
                      # of just strings that happens to be integers in radix 10 in the range<\/span><\/div>\n
                      # of 64 bit signed integers.<\/span><\/div>\n
                      # The following configuration setting sets the limit in the size of the<\/span><\/div>\n
                      # set in order to use this special memory saving encoding.<\/span><\/div>\n
                      set-max-intset-entries 512<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Similarly to hashes and lists, sorted sets are also specially encoded in<\/span><\/div>\n
                      # order to save a lot of space. This encoding is only used when the length and<\/span><\/div>\n
                      # elements of a sorted set are below the following limits:<\/span><\/div>\n
                      zset-max-ziplist-entries 128<\/span><\/div>\n
                      zset-max-ziplist-value 64<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in<\/span><\/div>\n
                      # order to help rehashing the main Redis hash table (the one mapping top-level<\/span><\/div>\n
                      # keys to values). The hash table implementation Redis uses (see dict.c)<\/span><\/div>\n
                      # performs a lazy rehashing: the more operation you run into an hash table<\/span><\/div>\n
                      # that is rehashing, the more rehashing “steps” are performed, so if the<\/span><\/div>\n
                      # server is idle the rehashing is never complete and some more memory is used<\/span><\/div>\n
                      # by the hash table.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # The default is to use this millisecond 10 times every second in order to<\/span><\/div>\n
                      # active rehashing the main dictionaries, freeing memory when possible.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # If unsure:<\/span><\/div>\n
                      # use “activerehashing no” if you have hard latency requirements and it is<\/span><\/div>\n
                      # not a good thing in your environment that Redis can reply form time to time<\/span><\/div>\n
                      # to queries with 2 milliseconds delay.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # use “activerehashing yes” if you don’t have such hard requirements but<\/span><\/div>\n
                      # want to free memory asap when possible.<\/span><\/div>\n
                      activerehashing yes<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # The client output buffer limits can be used to force disconnection of clients<\/span><\/div>\n
                      # that are not reading data from the server fast enough for some reason (a<\/span><\/div>\n
                      # common reason is that a Pub\/Sub client can’t consume messages as fast as the<\/span><\/div>\n
                      # publisher can produce them).<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # The limit can be set differently for the three different classes of clients:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # normal -> normal clients<\/span><\/div>\n
                      # slave\u00a0 -> slave clients and MONITOR clients<\/span><\/div>\n
                      # pubsub -> clients subcribed to at least one pubsub channel or pattern<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # The syntax of every client-output-buffer-limit directive is the following:<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds><\/span><\/div>\n
                      #<\/span><\/div>\n
                      # A client is immediately disconnected once the hard limit is reached, or if<\/span><\/div>\n
                      # the soft limit is reached and remains reached for the specified number of<\/span><\/div>\n
                      # seconds (continuously).<\/span><\/div>\n
                      # So for instance if the hard limit is 32 megabytes and the soft limit is<\/span><\/div>\n
                      # 16 megabytes \/ 10 seconds, the client will get disconnected immediately<\/span><\/div>\n
                      # if the size of the output buffers reach 32 megabytes, but will also get<\/span><\/div>\n
                      # disconnected if the client reaches 16 megabytes and continuously overcomes<\/span><\/div>\n
                      # the limit for 10 seconds.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # By default normal clients are not limited because they don’t receive data<\/span><\/div>\n
                      # without asking (in a push way), but just after a request, so only<\/span><\/div>\n
                      # asynchronous clients may create a scenario where data is requested faster<\/span><\/div>\n
                      # than it can read.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Instead there is a default limit for pubsub and slave clients, since<\/span><\/div>\n
                      # subscribers and slaves receive data in a push fashion.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Both the hard or the soft limit can be disabled by setting them to zero.<\/span><\/div>\n
                      client-output-buffer-limit normal 0 0 0<\/span><\/div>\n
                      client-output-buffer-limit slave 256mb 64mb 60<\/span><\/div>\n
                      client-output-buffer-limit pubsub 32mb 8mb 60<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Redis calls an internal function to perform many background tasks, like<\/span><\/div>\n
                      # closing connections of clients in timeot, purging expired keys that are<\/span><\/div>\n
                      # never requested, and so forth.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # Not all tasks are perforemd with the same frequency, but Redis checks for<\/span><\/div>\n
                      # tasks to perform accordingly to the specified “hz” value.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # By default “hz” is set to 10. Raising the value will use more CPU when<\/span><\/div>\n
                      # Redis is idle, but at the same time will make Redis more responsive when<\/span><\/div>\n
                      # there are many keys expiring at the same time, and timeouts may be<\/span><\/div>\n
                      # handled with more precision.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # The range is between 1 and 500, however a value over 100 is usually not<\/span><\/div>\n
                      # a good idea. Most users should use the default of 10 and raise this up to<\/span><\/div>\n
                      # 100 only in environments where very low latency is required.<\/span><\/div>\n
                      hz 10<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # When a child rewrites the AOF file, if the following option is enabled<\/span><\/div>\n
                      # the file will be fsync-ed every 32 MB of data generated. This is useful<\/span><\/div>\n
                      # in order to commit the file to the disk more incrementally and avoid<\/span><\/div>\n
                      # big latency spikes.<\/span><\/div>\n
                      aof-rewrite-incremental-fsync yes<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      ################################## INCLUDES ###################################<\/span><\/div>\n
                      \u00a0<\/span><\/div>\n
                      # Include one or more other config files here.\u00a0 This is useful if you<\/span><\/div>\n
                      # have a standard template that goes to all Redis server but also need<\/span><\/div>\n
                      # to customize a few per-server settings.\u00a0 Include files can include<\/span><\/div>\n
                      # other files, so use this wisely.<\/span><\/div>\n
                      #<\/span><\/div>\n
                      # include \/path\/to\/local.conf<\/span><\/div>\n
                      # include \/path\/to\/other.conf<\/span><\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

                      \u5b89\u88c5Redis Redis\u7684\u4ecb\u7ecd: redis\u662f\u4e00\u4e2a\u5f00\u6e90\u7684key-value\u6570\u636e\u5e93,\u5b83\u53c8\u7ecf\u5e38\u88ab\u8ba4\u4e3a\u662f\u4e00\u4e2a\u6570\u636e\u7ed3 […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[23],"tags":[25,26],"class_list":["post-327","post","type-post","status-publish","format-standard","hentry","category-nosql","tag-nosql","tag-redis"],"_links":{"self":[{"href":"http:\/\/www.royalwzy.com\/index.php?rest_route=\/wp\/v2\/posts\/327","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.royalwzy.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.royalwzy.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.royalwzy.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.royalwzy.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=327"}],"version-history":[{"count":0,"href":"http:\/\/www.royalwzy.com\/index.php?rest_route=\/wp\/v2\/posts\/327\/revisions"}],"wp:attachment":[{"href":"http:\/\/www.royalwzy.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=327"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.royalwzy.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=327"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.royalwzy.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=327"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}