Redis 优化要点

http://www.imooc.com/article/3645
http://www.cnblogs.com/mushroom/p/4738170.html
http://linusp.github.io/2015/12/16/redis-performance-analysis.html
https://segmentfault.com/a/1190000002906345

#info 分析

## Memory
>实际缓存占用的内存和Redis自身运行所占用的内存(如元数据、lua)。
>它是由Redis使用内存分配器分配的内存,所以这个数据并没有把内存碎片浪费掉的内存给统计进去
>如果used_memory > 可用最大内存,那么操作系统开始进行内存与swap空间交换
>当 rss > used ,且两者的值相差较大时,表示存在(内部或外部的)内存碎片。
>内存碎片的比率可以通过 mem_fragmentation_ratio 的值看出。
>当 used > rss 时,表示 Redis 的部分内存被操作系统换出到交换空间了,在这种情况下,操作可能会产生明显的延迟

>used_memory:9892187056
>used_memory_human:9.21G

>从操作系统上显示已经分配的内存总量, 包括碎片
>used_memory_rss:11148713984
>used_memory_peak:11236792296
>used_memory_peak_human:10.47G
>used_memory_lua:35840

## 内存碎片率
>内存碎片率稍大于1是合理的,这个值表示内存碎片率比较低,也说明redis没有发生内存交换。
>但如果内存碎片率超过1.5,那就说明Redis消耗了实际需要物理内存的150%,其中50%是内存碎片率
>若是内存碎片率低于1的话,说明Redis内存分配超出了物理内存,操作系统正在进行内存交换。内存交换会引起非常明显的响应延迟
>mem_fragmentation_ratio:1.13
>mem_allocator:jemalloc-3.6.0

## stats
>total_commands_processed:105868 #总共处理的命令数
>instantaneous_ops_per_sec:0
>rejected_connections:0
>evicted_keys:0 #因为maxmemory限制导致key被回收删除的数量

# 性能分析

## 延迟

>redis-cli -h 127.0.0.1 -p 6379 --latency
>持续采样,结果单位是ms;
>redis-cli -h 127.0.0.1 -p 6379 -–latency-history
>间隔采样,结果单位是ms;

## bigkeys

>redis-cli -h 127.0.0.1 -p 6379 --bigkeys
>持续采样,实时输出当时得到的 value 占用空间最大的 key 值

## 慢日志

>默认配置
>slowlog-log-slower-than 10000
>slowlog-max-len 128

>获取慢日志
>slowlog get 3

## 统计

>redis-cli -h 127.0.0.1 -p 6379 info commandstats
>查看所有命令统计的快照,执行次数,所耗费的毫秒数,总时间和平均时间

## 调试

>redis-cli -h 127.0.0.1 -p 6379 monitor

## 内存占用分析

redis-rdb-tools
>pip install rdbtools
>rdb -c memory /var/redis/6379/dump.rdb > memory.csv

# 优化与禁忌

停止使用 KEYS *,如果避免不了,请使用scan命令
精简键名和键值,减小key长度,压缩value
设置 key 值的过期时间,避免长时间占用内存,缓解同步和持久化的压力
选择合适的回收策略,如果不能丢数据则建议使用 volatile-lru 策略,如果key可以自动重建则推荐allkeys-lru
业务层要考虑读写分离和主从模式
合理分配snapshot,aof,主上关闭aof和snapshot,在主从上开启snapshot和aof
如果数据不需要持久,可关闭所有的持久化方式可以获得最佳的性能以及最大的内存使用量
合理选择最优的数据结构解决实际问题,那样既可以提高效率又可以节省内存
合理使用长连接
maxmemory=8g, 不要让你的Redis所在机器物理内存使用超过实际内存总量的3/5
sysctl vm.overcommit_memory=1
关闭vm-enabled,3.0以后默认废弃

解决保存快照失败后redis无法写入的问题
>config set stop-writes-on-bgsave-error no

定期日志重写,减小aof重载时的时间开销
>auto-aof-rewrite-percentage 100
>auto-aof-rewrite-min-size 64mb

# 安全
使用普通用户启动服务,且禁止该用户登录
在可以保证内网安全的情况下,无密码性能最好
客户端可能会发送config命令,会有安全问题,建议禁用
客户端可能会发送flushall、flushdb命令,为避免误操作,建议禁用
客户端可能会发送save命令,会严重影响服务器的性能,建议禁用并使用bgsave替代

>rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command KEYS ""
rename-command save ""

# 备份策略
主关闭aof, 开启rdb
每十分钟/10000变更生成一次rdb
每个小时保存一次最新的rdb到当前磁盘
每个小时保存一次

选择一台从节点,开启rdb,开启aof,并定期重载日志
```shell
path=/opt/data/redis/
name=dump_6380.rdb
file=$(date -d "yesterday" +"%Y%m%d%H.rdb")
/bin/mv $path/$name $path/$file
echo "move file $path/$file"

file=$(date -d "-3 days" +"%Y%m%d%H.rdb")
/bin/rm -f $path/$file
```

Redis常用命令

Redis常用命令集
1)连接操作命令
quit:关闭连接(connection)
auth:简单密码认证
help cmd: 查看cmd帮助,例如:help quit

2)持久化
save:将数据同步保存到磁盘
bgsave:将数据异步保存到磁盘
lastsave:返回上次成功将数据保存到磁盘的Unix时戳
shundown:将数据同步保存到磁盘,然后关闭服务

3)远程服务控制
info:提供服务器的信息和统计
monitor:实时转储收到的请求
slaveof:改变复制策略设置
config:在运行时配置Redis服务器

4)对value操作的命令
exists(key):确认一个key是否存在
del(key):删除一个key
type(key):返回值的类型
keys(pattern):返回满足给定pattern的所有key
randomkey:随机返回key空间的一个
keyrename(oldname, newname):重命名key
dbsize:返回当前数据库中key的数目
expire:设定一个key的活动时间(s)
ttl:获得一个key的活动时间
select(index):按索引查询
move(key, dbindex):移动当前数据库中的key到dbindex数据库
flushdb:删除当前选择数据库中的所有key
flushall:删除所有数据库中的所有key

5)String
set(key, value):给数据库中名称为key的string赋予值value
get(key):返回数据库中名称为key的string的value
getset(key, value):给名称为key的string赋予上一次的value
mget(key1, key2,…, key N):返回库中多个string的value
setnx(key, value):添加string,名称为key,值为value
setex(key, time, value):向库中添加string,设定过期时间time
mset(key N, value N):批量设置多个string的值
msetnx(key N, value N):如果所有名称为key i的string都不存在
incr(key):名称为key的string增1操作
incrby(key, integer):名称为key的string增加integer
decr(key):名称为key的string减1操作
decrby(key, integer):名称为key的string减少integer
append(key, value):名称为key的string的值附加value
substr(key, start, end):返回名称为key的string的value的子串

6)List
rpush(key, value):在名称为key的list尾添加一个值为value的元素
lpush(key, value):在名称为key的list头添加一个值为value的 元素
llen(key):返回名称为key的list的长度
lrange(key, start, end):返回名称为key的list中start至end之间的元素
ltrim(key, start, end):截取名称为key的list
lindex(key, index):返回名称为key的list中index位置的元素
lset(key, index, value):给名称为key的list中index位置的元素赋值
lrem(key, count, value):删除count个key的list中值为value的元素
lpop(key):返回并删除名称为key的list中的首元素
rpop(key):返回并删除名称为key的list中的尾元素
blpop(key1, key2,… key N, timeout):lpop命令的block版本。
brpop(key1, key2,… key N, timeout):rpop的block版本。
rpoplpush(srckey, dstkey):返回并删除名称为srckey的list的尾元素,并将该元素添加到名称为dstkey的list的头部

7)Set
sadd(key, member):向名称为key的set中添加元素member
srem(key, member) :删除名称为key的set中的元素member
spop(key) :随机返回并删除名称为key的set中一个元素
smove(srckey, dstkey, member) :移到集合元素
scard(key) :返回名称为key的set的基数
sismember(key, member) :member是否是名称为key的set的元素
sinter(key1, key2,…key N) :求交集
sinterstore(dstkey, (keys)) :求交集并将交集保存到dstkey的集合
sunion(key1, (keys)) :求并集
sunionstore(dstkey, (keys)) :求并集并将并集保存到dstkey的集合
sdiff(key1, (keys)) :求差集
sdiffstore(dstkey, (keys)) :求差集并将差集保存到dstkey的集合
smembers(key) :返回名称为key的set的所有元素
srandmember(key) :随机返回名称为key的set的一个元素

8)Hash
hset(key, field, value):向名称为key的hash中添加元素field
hget(key, field):返回名称为key的hash中field对应的value
hmget(key, (fields)):返回名称为key的hash中field i对应的value
hmset(key, (fields)):向名称为key的hash中添加元素field
hincrby(key, field, integer):将名称为key的hash中field的value增加integer
hexists(key, field):名称为key的hash中是否存在键为field的域
hdel(key, field):删除名称为key的hash中键为field的域
hlen(key):返回名称为key的hash中元素个数
hkeys(key):返回名称为key的hash中所有键
hvals(key):返回名称为key的hash中所有键对应的value
hgetall(key):返回名称为key的hash中所有的键(field)及其对应的value

Redis高级应用
1、安全性
设置客户端连接后进行任何操作指定前需要密码,一个外部用户可以再一秒钟进行150W次访问,具体操作密码修改设置redis.conf里面的requirepass属性给予密码,当然我这里给的是primos
之后如果想操作可以采用登陆的时候就授权使用:
sudo /opt/java/redis/bin/redis-cli -a primos
或者是进入以后auth primos然后就可以随意操作了

2、主从复制
做这个操作的时候我准备了两个虚拟机,ip分别是192.168.15.128和192.168.15.133
通过主从复制可以允许多个slave server拥有和master server相同的数据库副本
具体配置是在slave上面配置slave
slaveof 192.168.15.128 6379
masterauth primos
如果没有主从同步那么就检查一下是不是防火墙的问题,我用的是ufw,设置一下sudo ufw allow 6379就可以了
这个时候可以通过info查看具体的情况

3、事务处理
redis对事务的支持还比较简单,redis只能保证一个client发起的事务中的命令可以连续执行,而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时,这个连接会进入一个事务的上下文,连接后续命令不会立即执行,而是先放到一个队列中,当执行exec命令时,redis会顺序的执行队列中的所有命令。
比如我下面的一个例子
set age 100
multi
set age 10
set age 20
exec
get age --这个内容就应该是20
multi
set age 20
set age 10
exec
get age --这个时候的内容就成了10,充分体现了一下按照队列顺序执行的方式
discard 取消所有事务,也就是事务回滚
不过在redis事务执行有个别错误的时候,事务不会回滚,会把不错误的内容执行,错误的内容直接放弃,目前最新的是2.6.7也有这个问题的
乐观锁
watch key如果没watch的key有改动那么outdate的事务是不能执行的

4、持久化机制
redis是一个支持持久化的内存数据库
snapshotting快照方式,默认的存储方式,默认写入dump.rdb的二进制文件中,可以配置redis在n秒内如果超过m个key被修改过就自动做快照
append-only file aof方式,使用aof时候redis会将每一次的函 数都追加到文件中,当redis重启时会重新执行文件中的保存的写命
令在内存中。
5、发布订阅消息 sbusribe publish操作,其实就类似linux下面的消息发布
6、虚拟内存的使用
可以配置vm功能,保存路径,最大内存上线,页面多少,页面大小,最大工作线程
临时修改ip地址ifconfig eth0 192.168.15.129

redis-cli参数
Usage: redis-cli [OPTIONS] [cmd [arg [arg ...]]]
-h Server hostname (default: 127.0.0.1)
-p Server port (default: 6379)
-s Server socket (overrides hostname and port)
-a Password to use when connecting to the server
-r Execute specified command N times
-i When -r is used, waits seconds per command.
It is possible to specify sub-second times like -i 0.1
-n Database number
-x Read last argument from STDIN
-d Multi-bulk delimiter in for raw formatting (default: \n)
-c Enable cluster mode (follow -ASK and -MOVED redirections)
--raw Use raw formatting for replies (default when STDOUT is not a tty)
--latency Enter a special mode continuously sampling latency
--slave Simulate a slave showing commands received from the master
--pipe Transfer raw Redis protocol from stdin to server
--bigkeys Sample Redis keys looking for big keys
--eval Send an EVAL command using the Lua script at
--help Output this help and exit
--version Output version and exit

Examples:
cat /etc/passwd | redis-cli -x set mypasswd
redis-cli get mypasswd
redis-cli -r 100 lpush mylist x
redis-cli -r 100 -i 1 info | grep used_memory_human:
redis-cli --eval myscript.lua key1 key2 , arg1 arg2 arg3
(Note: when using --eval the comma separates KEYS[] from ARGV[] items)

常用命令:
1) 查看keys个数
keys * // 查看所有keys
keys prefix_* // 查看前缀为"prefix_"的所有keys

2) 清空数据库
flushdb // 清除当前数据库的所有keys
flushall // 清除所有数据库的所有keys

redis vs ssdb, hmset效率对比

平台环境:
软件 OS X 10.9.5 (13F34)
处理器 2.6 GHz Intel Core i5
内存 8 GB 1600 MHz DDR3
硬盘 500G SSD

软件环境:
redis 2.8.13
ssdb 1.7.0.0

测试总结:
使用php-redis驱动测试php连接redis和ssdb进入hmset持续写入10万个Key。
redis用时24s,ssdb用时120s,ssdb表现相差近6倍。

测试结果:
redis test start
Job start, 512.000000 kb, 2014-10-11 13:31:59
Job 10000 done, 512.000000 kb, 2014-10-11 13:32:01
Job 20000 done, 512.000000 kb, 2014-10-11 13:32:02
Job 30000 done, 512.000000 kb, 2014-10-11 13:32:05
Job 40000 done, 512.000000 kb, 2014-10-11 13:32:08
Job 50000 done, 512.000000 kb, 2014-10-11 13:32:13
Job 60000 done, 512.000000 kb, 2014-10-11 13:32:15
Job 70000 done, 512.000000 kb, 2014-10-11 13:32:17
Job 80000 done, 512.000000 kb, 2014-10-11 13:32:19
Job 90000 done, 512.000000 kb, 2014-10-11 13:32:21
Job 100000 done, 512.000000 kb, 2014-10-11 13:32:23
Job start, 512.000000 kb, 2014-10-11 13:32:23

ssdb test start
Job start, 512.000000 kb, 2014-10-11 13:32:23
Job 10000 done, 512.000000 kb, 2014-10-11 13:32:33
Job 20000 done, 512.000000 kb, 2014-10-11 13:32:44
Job 30000 done, 512.000000 kb, 2014-10-11 13:32:57
Job 40000 done, 512.000000 kb, 2014-10-11 13:33:10
Job 50000 done, 512.000000 kb, 2014-10-11 13:33:22
Job 60000 done, 512.000000 kb, 2014-10-11 13:33:35
Job 70000 done, 512.000000 kb, 2014-10-11 13:33:49
Job 80000 done, 512.000000 kb, 2014-10-11 13:34:00
Job 90000 done, 512.000000 kb, 2014-10-11 13:34:12
Job 100000 done, 512.000000 kb, 2014-10-11 13:34:23
Job start, 512.000000 kb, 2014-10-11 13:34:23

测试代码:

#!/usr/bin/env php
<?php
$test = new redis_test();
$test->totalSize = 100000;
$test->run();

class redis_test
{
    public $totalSize=1000000;

    function printf()
    {
      $args = func_get_args();
      if(count($args) == 1){
        $msg = $args[0].PHP_EOL;
      }else{
        $args[0] = $args[0].PHP_EOL;
        $msg = call_user_func_array("sprintf", $args);
      }

      echo $msg;
    }

    function run()
    {
        //测试redis->hmset()
        $this->printf("redis test start");
        $redis = new redis();
        $redis->connect('127.0.0.1', 6379);
        $this->test($redis);

        //测试ssdb->hmset()
        $this->printf("ssdb test start");
        $redis = new redis();
        $redis->connect('127.0.0.1', 8888);
        $this->test($redis);
    }

    function test($redis)
    {
        //导出一条测试记录
        $row = array (
          'id' => '1',
          'product' => '1',
          'imei' => '000000000000000',
          'model' => 'Galaxy Note 3 - 4.4.2 - API 19 - 1080x1920',
          'vcode' => '6',
          'vcoded' => '11',
          'channel' => '10001',
          'download' => '0',
          'ctime' => '1395992425',
          'year' => '2014',
          'month' => '201403',
          'week' => '201413',
          'day' => '20140328',
          'day1' => '1',
          'day2' => '1',
          'day3' => '1',
          'day4' => '1',
          'day5' => '1',
          'day6' => '1',
          'day7' => '1',
          'day14' => '1',
          'day30' => '0',
          'day60' => '0',
          'vcode_1' => '0',
          'vcode_2' => '0',
          'vcode_3' => '0',
          'vcode_6' => '20140710',
          'vcode_7' => '20140331',
          'vcode_8' => '0',
          'vcode_9' => '20140414',
          'vcode_10' => '0',
          'vcode_11' => '20140710',
          'vcode_12' => '0',
          'vcode_13' => '0',
          'vcode_14' => '0',
          'vcode_15' => '0',
          'vcode_16' => '0',
          'vcode_17' => '0',
          'vcode_18' => '0',
          'vcode_19' => '0',
          'last_act_year' => '2014',
          'last_act_month' => '201407',
          'last_act_week' => '201428',
          'last_act_day' => '20140710',
          'offday' => '77',
          'lose' => '1',
        );

        $this->printf("Job start, %s, %s", $this->memory_get_usage(), date("Y-m-d H:i:s"));
        for($i=1; $i<=$this->totalSize; $i++)
        {
            $row["id"]    = $i;
            $row["imei"]  = md5(rand(). microtime(true));
            $row["model"] = rand();

            $redis->hmset($row["imei"], $row);

            if($i % 10000 === 0)
                $this->printf("Job %s done, %s, %s", $i, $this->memory_get_usage(), date("Y-m-d H:i:s"));
        }

        $this->printf("Job start, %s, %s", $this->memory_get_usage(), date("Y-m-d H:i:s"));
    }

    function memory_get_usage()
    {
        $size = memory_get_usage(true);
        $unit=array('b ','kb','mb','gb','tb','pb');
        return sprintf("%02f", @round($size/pow(1024,($i=floor(log($size,1024)))), 2)).' '.$unit[$i];
    }
}

issue反馈:https://github.com/ideawu/ssdb/issues/448

php redis client 稳定性测试

一直有个想法,做一个只有redis作数据库的系统,一直对redis的功能比较赞赏,但不知道redis的单线程稳定性如何,之前测试过100万Key的写入锁,今天又测试了一下正常读写下redis cli的get稳定性。

结果看起来还可以,2万次左右的单次读取锁0.001秒,如果每次展示需要读取300次cache,整体来说,在redis上的时间损失也不超过0.1秒,跟mysql动则0.1秒的查询效率来看,还是快得多了。

但还不会做redis db集群和数据恢复,学习ing。
官方网站 http://redis.io/
Redis命令 http://redis.io/commands
Redis协议 http://redis.io/topics/protocol
NoSQLFan Redis资料汇总专题 http://blog.nosqlfan.com/html/3537.html
继续阅读php redis client 稳定性测试

Redis主从结构备忘

redis的主从复制配置
http://www.cnblogs.com/weafer/archive/2011/09/20/2182750.html

Redis 设计与实现
https://redisbook.readthedocs.org/en/latest/

以前有想过用 Memcache 实现M/S架构的负载均衡方案,直到听说了 Redis 后才发现它做得更好。
发了几天时间研究了一下 Redis ,感觉真的很不错,特整理一下!

以下操作都是在 SUSE Linux 11 下安装了好了PHP为例子,如果安装过程中有提示缺少的包可以使用
zypper search rpm-name 进行查询,然后用 zypper install rpm-name 安装

一:memcache 和 Redis 对比总结

[memecache 特点]
1:速度最快(没有自测,但网上有详细的测试用例)
2:支持水平扩展,可以任意添加节点

[redis 特点]
1:速度没有memcache快
2:支持M/S的主从备份
3:可以支持多数据库
4:操作指令很丰富
4:支持异步数据持久化(以文件保存)

总结:
1:如果是简单的数据缓存建议使用MEMCACHE。
2:如果要对单一操作的数据量非常的大则使用MEMCACHE
3: 如果想做性能很好的缓存集群可以用Redis(M/S读写分离,如weibo中的排行榜等)
4: 如果在高并发下又想保存数据则可以用Redis (如更新热门文章浏览次数,memcachedb也不错)

二:Redis 的详细安装,

将 redis 安装到 /usr/local/webserver/redis

1:从 http://redis.io/download 上下载安装包

wget http://redis.googlecode.com/files/redis-2.2.15.tar.gz
tar zxvf redis-2.2.15.tar.gz
cd redis-2.2.15
make

mkdir -p /usr/local/webserver/redis/conf
mkdir -p /usr/local/webserver/redis/run
mkdir -p /usr/local/webserver/redis/db
cp redis.conf /usr/local/webserver/redis/conf/
cd src
# 将 src 目录下所有可执行文件复制到安装目录
cp redis-benchmark redis-check-aof redis-check-dump redis-cli redis-server mkreleasehdr.sh /usr/local/webserver/redis/

2:修改配置文件中的如下选项
------- vi /usr/local/webserver/redis/conf/redis.conf --------
daemonize yes
pidfile /usr/local/webserver/redis/run/redis.pid
dir /usr/local/webserver/redis/db
--------------------------------------------------------------

3:创建服务脚本

------- vi /usr/local/webserver/redis/start.sh ---------
#!/bin/bash
/usr/local/webserver/redis/redis-server /usr/local/webserver/redis/conf/redis.conf
--------------------------------------------------------

------- vi /usr/local/webserver/redis/stop.sh ---------
#!/bin/bash
kill `cat /usr/local/webserver/redis/run/redis.pid`
--------------------------------------------------------

chmod a+x /usr/local/webserver/redis/start.sh /usr/local/webserver/redis/stop.sh

4:启动 redis 服务
/usr/local/webserver/redis/start.sh
验证证服务是否成功:
netstat -nlpt | grep 6379

5:启动客户端验证
/usr/local/webserver/redis/redis-cli
>set key1 val1
>get key1

三:Redis Master/Slave 主从集群配置

这里我们以本机配置 1台Master + 2台Slave 为例子,其中:

Master IP:127.0.0.1 PORT:6379
Slave1 IP:127.0.0.1 PORT:63791
Slave2 IP:127.0.0.1 PORT:63792

1:复制两个 Slave 目录,方便管理
cp -r /usr/local/webserver/redis /usr/local/webserver/redis-slave1
cp -r /usr/local/webserver/redis /usr/local/webserver/redis-slave2

2:修改 redis-slave1 的配置文件和服务脚本
-- vi /usr/local/webserver/redis-slave1/conf/redis.conf --
port 63791
pidfile /usr/local/webserver/redis-slave1/run/redis.pid
dir /usr/local/webserver/redis-slave1/db
slaveof 127.0.0.1 6379
----------------------------------------------------------

-- vi /usr/local/webserver/redis-slave1/start.sh --
#!/bin/bash
/usr/local/webserver/redis-slave1/redis-server /usr/local/webserver/redis-slave1/conf/redis.conf
---------------------------------------------------

------- vi /usr/local/webserver/redis-slave1/stop.sh ---------
#!/bin/bash
kill `cat /usr/local/webserver/redis-slave1/run/redis.pid`
--------------------------------------------------------

3:修改 redis-slave2 的配置文件和服务脚本
-- vi /usr/local/webserver/redis-slave2/conf/redis.conf --
port 63792
pidfile /usr/local/webserver/redis-slave2/run/redis.pid
dir /usr/local/webserver/redis-slave2/db
slaveof 127.0.0.1 6379
----------------------------------------------------------

-- vi /usr/local/webserver/redis-slave2/start.sh --
#!/bin/bash
/usr/local/webserver/redis-slave2/redis-server /usr/local/webserver/redis-slave2/conf/redis.conf
---------------------------------------------------

------- vi /usr/local/webserver/redis-slave2/stop.sh ---------
#!/bin/bash
kill `cat /usr/local/webserver/redis-slave2/run/redis.pid`
--------------------------------------------------------

4:启动 M/S 服务
/usr/local/webserver/redis/start.sh
/usr/local/webserver/redis-slave1/start.sh
/usr/local/webserver/redis-slave2/start.sh
验证服务是否正常: netstat -nlpt | grep redis-server 有3个端口存在证明成功了
0 0.0.0.0:6379
0 0.0.0.0:63791
0 0.0.0.0:63792

5:验证M/S服务是否生效
/usr/local/webserver/redis/redis-cli [默认连接端口:6379 的 Master服务]
>set key1 val1
>quit

/usr/local/webserver/redis/redis-cli -p 63791 [连接 Slave1 服务]
>get key1
"val1" (数据成功同步了)

/usr/local/webserver/redis/redis-cli -p 63792 [连接 Slave2 服务]
>get key1
"val1" (数据成功同步了)

四:安装 Redis PHP 扩展

Redis所有的客户端在 http://redis.io/clients [PHP选项卡] 基于性能选择安装 phpredis

在 https://github.com/nicolasff/phpredis/downloads 上下载源代码包到本地然后上传到服务器.

tar zxvf nicolasff-phpredis-2.1.3-167-ga5e53f1.tar.gz
cd nicolasff-phpredis-a5e53f1
phpize
./configure
make && make install

查看输出信息会告诉你 redis.so 的那个目录下,把它复制到PHP的扩展目录下
我的系统上是 /usr/lib/php5/extensions/

用 php --ini 找到 php.ini 的位置,加入以下行后重启WEB服务器
=========================
extension=redis.so
=========================

五:PHP负载开发方案

<?php
/**
 * Redis 操作,支持 Master/Slave 的负载集群
 *
 * @author V哥
 */
class RedisCluster{

    // 是否使用 M/S 的读写集群方案
    private $_isUseCluster = false;

    // Slave 句柄标记
    private $_sn = 0;

    // 服务器连接句柄
    private $_linkHandle = array(
        'master'=>null,// 只支持一台 Master
        'slave'=>array(),// 可以有多台 Slave
    );

    /**
     * 构造函数
     *
     * @param boolean $isUseCluster 是否采用 M/S 方案
     */
    public function __construct($isUseCluster=false){
        $this->_isUseCluster = $isUseCluster;
    }

    /**
     * 连接服务器,注意:这里使用长连接,提高效率,但不会自动关闭
     *
     * @param array $config Redis服务器配置
     * @param boolean $isMaster 当前添加的服务器是否为 Master 服务器
     * @return boolean
     */
    public function connect($config=array('host'=>'127.0.0.1','port'=>6379), $isMaster=true){
        // default port
        if(!isset($config['port'])){
            $config['port'] = 6379;
        }
        // 设置 Master 连接
        if($isMaster){
            $this->_linkHandle['master'] = new Redis();
            $ret = $this->_linkHandle['master']->pconnect($config['host'],$config['port']);
        }else{
            // 多个 Slave 连接
            $this->_linkHandle['slave'][$this->_sn] = new Redis();
            $ret = $this->_linkHandle['slave'][$this->_sn]->pconnect($config['host'],$config['port']);
            ++$this->_sn;
        }
        return $ret;
    }

    /**
     * 关闭连接
     *
     * @param int $flag 关闭选择 0:关闭 Master 1:关闭 Slave 2:关闭所有
     * @return boolean
     */
    public function close($flag=2){
        switch($flag){
            // 关闭 Master
            case 0:
                $this->getRedis()->close();
            break;
            // 关闭 Slave
            case 1:
                for($i=0; $i<$this->_sn; ++$i){
                    $this->_linkHandle['slave'][$i]->close();
                }
            break;
            // 关闭所有
            case 1:
                $this->getRedis()->close();
                for($i=0; $i<$this->_sn; ++$i){
                    $this->_linkHandle['slave'][$i]->close();
                }
            break;
        }
        return true;
    }

    /**
     * 得到 Redis 原始对象可以有更多的操作
     *
     * @param boolean $isMaster 返回服务器的类型 true:返回Master false:返回Slave
     * @param boolean $slaveOne 返回的Slave选择 true:负载均衡随机返回一个Slave选择 false:返回所有的Slave选择
     * @return redis object
     */
    public function getRedis($isMaster=true,$slaveOne=true){
        // 只返回 Master
        if($isMaster){
            return $this->_linkHandle['master'];
        }else{
            return $slaveOne ? $this->_getSlaveRedis() : $this->_linkHandle['slave'];
        }
    }

    /**
     * 写缓存
     *
     * @param string $key 组存KEY
     * @param string $value 缓存值
     * @param int $expire 过期时间, 0:表示无过期时间
     */
    public function set($key, $value, $expire=0){
        // 永不超时
        if($expire == 0){
            $ret = $this->getRedis()->set($key, $value);
        }else{
            $ret = $this->getRedis()->setex($key, $expire, $value);
        }
        return $ret;
    }

    /**
     * 读缓存
     *
     * @param string $key 缓存KEY,支持一次取多个 $key = array('key1','key2')
     * @return string || boolean  失败返回 false, 成功返回字符串
     */
    public function get($key){
        // 是否一次取多个值
        $func = is_array($key) ? 'mGet' : 'get';
        // 没有使用M/S
        if(! $this->_isUseCluster){
            return $this->getRedis()->{$func}($key);
        }
        // 使用了 M/S
        return $this->_getSlaveRedis()->{$func}($key);
    }

    /**
     * 条件形式设置缓存,如果 key 不存时就设置,存在时设置失败
     *
     * @param string $key 缓存KEY
     * @param string $value 缓存值
     * @return boolean
     */
    public function setnx($key, $value){
        return $this->getRedis()->setnx($key, $value);
    }

    /**
     * 删除缓存
     *
     * @param string || array $key 缓存KEY,支持单个健:"key1" 或多个健:array('key1','key2')
     * @return int 删除的健的数量
     */
    public function remove($key){
        // $key => "key1" || array('key1','key2')
        return $this->getRedis()->delete($key);
    }

    /**
     * 值加加操作,类似 ++$i ,如果 key 不存在时自动设置为 0 后进行加加操作
     *
     * @param string $key 缓存KEY
     * @param int $default 操作时的默认值
     * @return int 操作后的值
     */
    public function incr($key,$default=1){
        if($default == 1){
            return $this->getRedis()->incr($key);
        }else{
            return $this->getRedis()->incrBy($key, $default);
        }
    }

    /**
     * 值减减操作,类似 --$i ,如果 key 不存在时自动设置为 0 后进行减减操作
     *
     * @param string $key 缓存KEY
     * @param int $default 操作时的默认值
     * @return int 操作后的值
     */
    public function decr($key,$default=1){
        if($default == 1){
            return $this->getRedis()->decr($key);
        }else{
            return $this->getRedis()->decrBy($key, $default);
        }
    }

    /**
     * 添空当前数据库
     *
     * @return boolean
     */
    public function clear(){
        return $this->getRedis()->flushDB();
    }

    /* =================== 以下私有方法 =================== */

    /**
     * 随机 HASH 得到 Redis Slave 服务器句柄
     *
     * @return redis object
     */
    private function _getSlaveRedis(){
        // 就一台 Slave 机直接返回
        if($this->_sn <= 1){
            return $this->_linkHandle['slave'][0];
        }
        // 随机 Hash 得到 Slave 的句柄
        $hash = $this->_hashId(mt_rand(), $this->_sn);
        return $this->_linkHandle['slave'][$hash];
    }

    /**
     * 根据ID得到 hash 后 0~m-1 之间的值
     *
     * @param string $id
     * @param int $m
     * @return int
     */
    private function _hashId($id,$m=10)
    {
        //把字符串K转换为 0~m-1 之间的一个值作为对应记录的散列地址
        $k = md5($id);
        $l = strlen($k);
        $b = bin2hex($k);
        $h = 0;
        for($i=0;$i<$l;$i++)
        {
            //相加模式HASH
            $h += substr($b,$i*2,2);
        }
        $hash = ($h*1)%$m;
        return $hash;
    }

}// End Class

// ================= TEST DEMO =================

// 只有一台 Redis 的应用
$redis = new RedisCluster();
$redis->connect(array('host'=>'127.0.0.1','port'=>6379));
$redis->set('id',35);
var_dump($redis->get('id'));

// 有一台 Master 和 多台Slave 的集群应用
$redis = new RedisCluster(true);
$redis->connect(array('host'=>'127.0.0.1','port'=>6379), true);// master
$redis->connect(array('host'=>'127.0.0.1','port'=>63791), false);// slave 1
$redis->connect(array('host'=>'127.0.0.1','port'=>63792), false);// slave 2
$redis->set('id',100);
for($i=1; $i< =100; ++$i){ var_dump($redis->get('id')).PHP_EOL;
}

// phpRedis 扩展的更多高级操作
$redis = new RedisCluster();
$redis->connect(array('host'=>'127.0.0.1','port'=>6379));
$ret = $redis->getRedis()->ping();// phpRedis 原始API
var_dump($ret);

[phpReadis API手册]
https://github.com/nicolasff/phpredis

[redis 配置说明--来自网络]

1. Redis默认不是以守护进程的方式运行,可以通过该配置项修改,使用yes启用守护进程
daemonize no
2. 当Redis以守护进程方式运行时,Redis默认会把pid写入/var/run/redis.pid文件,可以通过pidfile指定
pidfile /var/run/redis.pid
3. 指定Redis监听端口,默认端口为6379,作者在自己的一篇博文中解释了为什么选用6379作为默认端口,因为6379在手机按键上MERZ对应的号码,而MERZ取自意大利歌女Alessia Merz的名字
port 6379
4. 绑定的主机地址
bind 127.0.0.1
5.当 客户端闲置多长时间后关闭连接,如果指定为0,表示关闭该功能
timeout 300
6. 指定日志记录级别,Redis总共支持四个级别:debug、verbose、notice、warning,默认为verbose
loglevel verbose
7. 日志记录方式,默认为标准输出,如果配置Redis为守护进程方式运行,而这里又配置为日志记录方式为标准输出,则日志将会发送给/dev/null
logfile stdout
8. 设置数据库的数量,默认数据库为0,可以使用SELECT 命令在连接上指定数据库id
databases 16
9. 指定在多长时间内,有多少次更新操作,就将数据同步到数据文件,可以多个条件配合
save
Redis默认配置文件中提供了三个条件:
save 900 1
save 300 10
save 60 10000
分别表示900秒(15分钟)内有1个更改,300秒(5分钟)内有10个更改以及60秒内有10000个更改。

10. 指定存储至本地数据库时是否压缩数据,默认为yes,Redis采用LZF压缩,如果为了节省CPU时间,可以关闭该选项,但会导致数据库文件变的巨大
rdbcompression yes
11. 指定本地数据库文件名,默认值为dump.rdb
dbfilename dump.rdb
12. 指定本地数据库存放目录
dir ./
13. 设置当本机为slav服务时,设置master服务的IP地址及端口,在Redis启动时,它会自动从master进行数据同步
slaveof
14. 当master服务设置了密码保护时,slav服务连接master的密码
masterauth
15. 设置Redis连接密码,如果配置了连接密码,客户端在连接Redis时需要通过AUTH 命令提供密码,默认关闭
requirepass foobared
16. 设置同一时间最大客户端连接数,默认无限制,Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数,如果设置 maxclients 0,表示不作限制。当客户端连接数到达限制时,Redis会关闭新的连接并向客户端返回max number of clients reached错误信息
maxclients 128
17. 指定Redis最大内存限制,Redis在启动时会把数据加载到内存中,达到最大内存后,Redis会先尝试清除已到期或即将到期的Key,当此方法处理 后,仍然到达最大内存设置,将无法再进行写入操作,但仍然可以进行读取操作。Redis新的vm机制,会把Key存放内存,Value会存放在swap区
maxmemory
18. 指定是否在每次更新操作后进行日志记录,Redis在默认情况下是异步的把数据写入磁盘,如果不开启,可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的,所以有的数据会在一段时间内只存在于内存中。默认为no
appendonly no
19. 指定更新日志文件名,默认为appendonly.aof
appendfilename appendonly.aof
20. 指定更新日志条件,共有3个可选值:
no:表示等操作系统进行数据缓存同步到磁盘(快)
always:表示每次更新操作后手动调用fsync()将数据写到磁盘(慢,安全)
everysec:表示每秒同步一次(折衷,默认值)
appendfsync everysec

21. 指定是否启用虚拟内存机制,默认值为no,简单的介绍一下,VM机制将数据分页存放,由Redis将访问量较少的页即冷数据swap到磁盘上,访问多的页面由磁盘自动换出到内存中(在后面的文章我会仔细分析Redis的VM机制)
vm-enabled no
22. 虚拟内存文件路径,默认值为/tmp/redis.swap,不可多个Redis实例共享
vm-swap-file /tmp/redis.swap
23. 将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0
vm-max-memory 0
24. Redis swap文件分成了很多的page,一个对象可以保存在多个page上面,但一个page上不能被多个对象共享,vm-page-size是要根据存储的 数据大小来设定的,作者建议如果存储很多小对象,page大小最好设置为32或者64bytes;如果存储很大大对象,则可以使用更大的page,如果不 确定,就使用默认值
vm-page-size 32
25. 设置swap文件中的page数量,由于页表(一种表示页面空闲或使用的bitmap)是在放在内存中的,,在磁盘上每8个pages将消耗1byte的内存。
vm-pages 134217728
26. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的,可能会造成比较长时间的延迟。默认值为4
vm-max-threads 4
27. 设置在向客户端应答时,是否把较小的包合并为一个包发送,默认为开启
glueoutputbuf yes
28. 指定在超过一定的数量或者最大的元素超过某一临界值时,采用一种特殊的哈希算法
hash-max-zipmap-entries 64
hash-max-zipmap-value 512
29. 指定是否激活重置哈希,默认为开启(后面在介绍Redis的哈希算法时具体介绍)
activerehashing yes
30. 指定包含其它的配置文件,可以在同一主机上多个Redis实例之间使用同一份配置文件,而同时各个实例又拥有自己的特定配置文件
include /path/to/local.conf

主从环境的安全备份
前提:现在有主从结构,主库没有配置持久化,从库配置AOF。(主库用来备份和写服务,从库用来提供读服务)
场景:哪一天主库突然宕了,怎么办?
非常危险的动作:重新启动主库。
要知道这样一来,最坏情况数据将全部丢失。因为主库没有配置持久化,所以主库的data目录只有从库连接主库请求resync的时候做快照留下来的dump.rdb文件。如果重启主库,主库会按照data目录下的dump.rdb来恢复数据。因此,如果从库是从最开始就配置好了的而且没有发生过再次请求resync,那么此时的dump.rdb将是空的。主库按照空的dump.rdb恢复数据,自然数据全无,从库发现主库能够连接上时会自动请求resync,从库也将拷贝一份空白的数据。

phpRedis性能测试

http://redis.io/clients
redis官方推荐了两个php的redis客户端,Predis和phpredis。其中,Predis为纯php实现,phpredis为C语言的扩展。

Predis为php源码码,扩展方便,但只支持php5.3+,phpredis性能应该会好一些,写了一个测试脚本来测试。
测试的笔记本配置为i7 2630Q+10G

phpredis
https://github.com/nicolasff/phpredis

redis.php

<?php
class cache
{
	function __construct()
	{
		$this->_instance();
	}
	
	protected function _instance()
	{
		static $_instance;

		if(empty($_instance))
			$_instance = $this->connect();
		return $_instance;
	}
	
	function connect()
	{
		$this->db = new redis();
		$this->db->connect('127.0.0.1', '6379');
		return $this;
	}

	function __call($method, $args)
	{
		return call_user_func_array(array($this->db, $method) , $args);
	}
}

$redis = new cache();
$key_pre = time();
echo "pre : $key_pre\n";

//测试百万次循环
$s = microtime(true);
while($total < 1000000)
{
	$total++;
}
$e = microtime(true);
printf("1 000 000 loop cost %4f\n", $e-$s);

//测试百万次写入
$total = 0;
$s = microtime(true);
while($total <= 1000000)
{
	$redis->set("$key_pre:{$total}", $total);
	$total++;
}
$e = microtime(true);
printf("1 000 000 set cost %4f, lastkey: %s\n", $e-$s, "$key_pre:{$total}");

//测试百万次读取
$total = 0;
$s = microtime(true);
while($total <= 1000000)
{
	$redis->get( "$key_pre:{$total}" );
	$total++;
}
$e = microtime(true);
printf("1 000 000 get cost %4f, lastkey: %s\n", $e-$s, "$key_pre:{$total}");

//测试百万级 key 查找
$total = 0;
$s = microtime(true);
$redis->keys("$key_pre:*");
$e = microtime(true);
printf("1 000 000 key find cost %4f\n", $e-$s);

执行结果

shuhai@Aspire:/wwwroot$ php redis.php
pre : 1358331812
1 000 000 loop cost 0.039773
1 000 000 set cost 91.499741, lastkey: 1358331812:1000001
1 000 000 get cost 111.465971, lastkey: 1358331812:1000001
1 000 000 key find cost 1.173917

phpcms v9中使用memcache

phpcms v9强大倒是一说,一些内置的缓存配置方法却没有明确的教程,比如memcache类。
phpcms已经内置了这个缓存,但一直不知道如何启用。

折腾了一晚,想把phpcms的setcache和getcache方法,配置成可以动态切换缓存类型,类型于ThinkPHP的机制。

最后无奈发现phpcms默认开发好像全是使用文件进行存储。
于是,只能在自己需要的地方加上memcache或者redis了,内核要改的话,也忒麻烦了。

配置文件:
cache/configs/cache.php

<?php

return array (
	'file1' => array (
		'type' => 'file',
		'debug' => true,
		'pconnect' => 0,
		'autoconnect' => 0
		),
	'memcache' => array (
		'hostname' => '192.168.0.106',
		'port' => 11211,
		'timeout' => 3600,
		'type' => 'memcache',
		'debug' => true,
		'pconnect' => 0,
		'autoconnect' => 0
	),
	'redis' => array (
		'hostname' => '192.168.0.106',
		'port' => 6379,
		'timeout' => 0,
		'type' => 'redis',
		'debug' => true,
		'pconnect' => 0,
		'autoconnect' => 0
	)
);

?>

文件配置文件的格式上看,和TP机乎一样,但不支持动态切换。

在需要的地方这样写,这里封装了一个获取记录的方法:

/**
 * 调用一个应用详情
 */
function appdetail($appid, $ttl=0)
{
	if(FALSE == is_int($appid)) return FALSE;
		
	$cache_type = 'memcache';
	$cache_name = sprintf(&quot;app_detail_id_%d&quot;, $appid);

	$cache_config = pc_base::load_config('cache');
	
	/* 系统是否支持 */
	$cache_support = !empty($cache_config[$cache_type]) &amp;&amp; class_exists($cache_type);

	if($cache_support)
	{
		$memcache = cache_factory::get_instance($cache_config)->get_cache('memcache');
		$app = $memcache->get($cache_name);
		$app = unserialize($app);
	}else{
		$app = getcache($cache_name);
	}
	
	if($app === false)
	{
		$db = pc_base::load_model('apps_model');
		$app = $db->get_one(array(&quot;id&quot;=>$appid), &quot;id,name&quot;);

		if($cache_support)
		{
			$memcache = cache_factory::get_instance($cache_config)->get_cache('memcache');
			$memcache->set($cache_name, serialize($app), $ttl);
		}else{
			setcache($cache_name, $app, '', $ttl);
		}
	}

	return $app;
}

大约的功能是检测系统是否支持memcache类,支持的话就直接使用memcache,如果不支持,就使用PHPCMS自带的缓存方法。

继续深入折腾setcache,看看是不是我的理解有误

周末在家折腾了一天,慢慢把PHPCMS的MVC和模板标签pc_tag给做熟了,可以肯定的下结论就是:
PHPCMS会把所有进入模板层的数据,进行数据缓存,比如content_tag.class.php中所有的方法,产生的数据还是会被再一次缓存到文件中。

我使用A机产生memcache的数据memcache_A1,使用PHPCMS调用A1以后,会在PHPCMS硬盘上产生PHPCMS_A1,当我的memcache_A1发生改变时,PHPCMS_A1读取的还是PHPCMS_A1这个缓存。
解决方是在pc_tag中,将缓存设置为0,则可以在后端使用其它缓存工具!

phpredis 中文说明

redis及phpredis相关安装教程:redis安装手册,中文配置手册,php-redis模块安装方法,Web管理phpRedisAdmin
redis-cli 命令中文版:redis-cli 命令中文版

Redis::__construct构造函数
$redis = new Redis();

connect, open 链接redis服务
参数
host: string,服务地址
port: int,端口号
timeout: float,链接时长 (可选, 默认为 0 ,不限链接时间)
注: 在redis.conf中也有时间,默认为300

pconnect, popen 长链接,即不会主动关闭的链接,需要手工关闭
参考上面

setOption 设置redis模式

getOption 查看redis设置的模式

ping 查看连接状态

get 得到某个key的值(string值)
如果该key不存在,return false

set 写入key 和 value(string值)
如果写入成功,return ture

setex 带生存时间的写入值
$redis->setex('key', 3600, 'value'); // sets key → value, with 1h TTL.

setnx 判断是否重复的,写入值
$redis->setnx('key', 'value');
$redis->setnx('key', 'value');

delete 删除指定key的值
返回已经删除key的个数(长整数)
$redis->delete('key1', 'key2');
$redis->delete(array('key3', 'key4', 'key5'));

ttl
得到一个key的生存时间

persist
移除生存时间到期的key
如果key到期 true 如果不到期 false

mset (redis版本1.1以上才可以用)
同时给多个key赋值
$redis->mset(array('key0' => 'value0', 'key1' => 'value1'));

multi, exec, discard
进入或者退出事务模式
参数可选Redis::MULTI或Redis::PIPELINE. 默认是 Redis::MULTI
Redis::MULTI:将多个操作当成一个事务执行
Redis::PIPELINE:让(多条)执行命令简单的,更加快速的发送给服务器,但是没有任何原子性的保证
discard:删除一个事务
返回值
multi(),返回一个redis对象,并进入multi-mode模式,一旦进入multi-mode模式,以后调用的所有方法都会返回相同的对象,只到exec()方法被调用。

watch, unwatch (代码测试后,不能达到所说的效果)
监测一个key的值是否被其它的程序更改。如果这个key在watch 和 exec (方法)间被修改,这个 MULTI/EXEC 事务的执行将失败(return false)
unwatch 取消被这个程序监测的所有key
参数,一对key的列表
$redis->watch('x');

$ret = $redis->multi() ->incr('x') ->exec();

subscribe *
方法回调。注意,该方法可能在未来里发生改变

publish *
发表内容到某一个通道。注意,该方法可能在未来里发生改变

exists
判断key是否存在。存在 true 不在 false

incr, incrBy
key中的值进行自增1,如果填写了第二个参数,者自增第二个参数所填的值
$redis->incr('key1');
$redis->incrBy('key1', 10);

decr, decrBy
做减法,使用方法同incr

getMultiple
传参
由key组成的数组
返回参数
如果key存在返回value,不存在返回false
$redis->set('key1', 'value1'); $redis->set('key2', 'value2'); $redis->set('key3', 'value3'); $redis->getMultiple(array('key1', 'key2', 'key3'));
$redis->lRem('key1', 'A', 2);
$redis->lRange('key1', 0, -1);

list相关操作
lPush
$redis->lPush(key, value);
在名称为key的list左边(头)添加一个值为value的 元素

rPush
$redis->rPush(key, value);
在名称为key的list右边(尾)添加一个值为value的 元素

lPushx/rPushx
$redis->lPushx(key, value);
在名称为key的list左边(头)/右边(尾)添加一个值为value的元素,如果value已经存在,则不添加

lPop/rPop
$redis->lPop('key');
输出名称为key的list左(头)起/右(尾)起的第一个元素,删除该元素

blPop/brPop
$redis->blPop('key1', 'key2', 10);
lpop命令的block版本。即当timeout为0时,若遇到名称为key i的list不存在或该list为空,则命令结束。如果timeout>0,则遇到上述情况时,等待timeout秒,如果问题没有解决,则对keyi+1开始的list执行pop操作

lSize
$redis->lSize('key');
返回名称为key的list有多少个元素

lIndex, lGet
$redis->lGet('key', 0);
返回名称为key的list中index位置的元素

lSet
$redis->lSet('key', 0, 'X');
给名称为key的list中index位置的元素赋值为value

lRange, lGetRange
$redis->lRange('key1', 0, -1);
返回名称为key的list中start至end之间的元素(end为 -1 ,返回所有)

lTrim, listTrim
$redis->lTrim('key', start, end);
截取名称为key的list,保留start至end之间的元素

lRem, lRemove
$redis->lRem('key', 'A', 2);
删除count个名称为key的list中值为value的元素。count为0,删除所有值为value的元素,count>0从头至尾删除count个值为value的元素,count<0从尾到头删除|count|个值为value的元素

lInsert
在名称为为key的list中,找到值为pivot 的value,并根据参数Redis::BEFORE | Redis::AFTER,来确定,newvalue 是放在 pivot 的前面,或者后面。如果key不存在,不会插入,如果 pivot不存在,return -1
$redis->delete('key1'); $redis->lInsert('key1', Redis::AFTER, 'A', 'X'); $redis->lPush('key1', 'A'); $redis->lPush('key1', 'B'); $redis->lPush('key1', 'C'); $redis->lInsert('key1', Redis::BEFORE, 'C', 'X');
$redis->lRange('key1', 0, -1);
$redis->lInsert('key1', Redis::AFTER, 'C', 'Y');
$redis->lRange('key1', 0, -1);
$redis->lInsert('key1', Redis::AFTER, 'W', 'value');

rpoplpush
返回并删除名称为srckey的list的尾元素,并将该元素添加到名称为dstkey的list的头部
$redis->delete('x', 'y');
$redis->lPush('x', 'abc'); $redis->lPush('x', 'def'); $redis->lPush('y', '123'); $redis->lPush('y', '456'); // move the last of x to the front of y. var_dump($redis->rpoplpush('x', 'y'));
var_dump($redis->lRange('x', 0, -1));
var_dump($redis->lRange('y', 0, -1));

string(3) "abc"
array(1) { [0]=> string(3) "def" }
array(3) { [0]=> string(3) "abc" [1]=> string(3) "456" [2]=> string(3) "123" }

SET操作相关
sAdd
向名称为key的set中添加元素value,如果value存在,不写入,return false
$redis->sAdd(key , value);

sRem, sRemove
删除名称为key的set中的元素value
$redis->sAdd('key1' , 'set1');
$redis->sAdd('key1' , 'set2');
$redis->sAdd('key1' , 'set3');
$redis->sRem('key1', 'set2');

sMove
将value元素从名称为srckey的集合移到名称为dstkey的集合
$redis->sMove(seckey, dstkey, value);

sIsMember, sContains
名称为key的集合中查找是否有value元素,有ture 没有 false
$redis->sIsMember(key, value);

sCard, sSize
返回名称为key的set的元素个数

sPop
随机返回并删除名称为key的set中一个元素

sRandMember
随机返回名称为key的set中一个元素,不删除

sInter
求交集

sInterStore
求交集并将交集保存到output的集合
$redis->sInterStore('output', 'key1', 'key2', 'key3')

sUnion
求并集
$redis->sUnion('s0', 's1', 's2');
s0,s1,s2 同时求并集

sUnionStore
求并集并将并集保存到output的集合
$redis->sUnionStore('output', 'key1', 'key2', 'key3');

sDiff
求差集

sDiffStore
求差集并将差集保存到output的集合

sMembers, sGetMembers
返回名称为key的set的所有元素

sort
排序,分页等
参数
'by' => 'some_pattern_*',
'limit' => array(0, 1),
'get' => 'some_other_pattern_*' or an array of patterns,
'sort' => 'asc' or 'desc',
'alpha' => TRUE,
'store' => 'external-key'
例子
$redis->delete('s'); $redis->sadd('s', 5); $redis->sadd('s', 4); $redis->sadd('s', 2); $redis->sadd('s', 1); $redis->sadd('s', 3);
var_dump($redis->sort('s')); // 1,2,3,4,5
var_dump($redis->sort('s', array('sort' => 'desc'))); // 5,4,3,2,1
var_dump($redis->sort('s', array('sort' => 'desc', 'store' => 'out'))); // (int)5

string命令
getSet
返回原来key中的值,并将value写入key
$redis->set('x', '42');
$exValue = $redis->getSet('x', 'lol'); // return '42', replaces x by 'lol'
$newValue = $redis->get('x')' // return 'lol'

append
string,名称为key的string的值在后面加上value
$redis->set('key', 'value1');
$redis->append('key', 'value2');
$redis->get('key');

getRange (方法不存在)
返回名称为key的string中start至end之间的字符
$redis->set('key', 'string value');
$redis->getRange('key', 0, 5);
$redis->getRange('key', -5, -1);

setRange (方法不存在)
改变key的string中start至end之间的字符为value
$redis->set('key', 'Hello world');
$redis->setRange('key', 6, "redis");
$redis->get('key');

strlen
得到key的string的长度
$redis->strlen('key');

getBit/setBit
返回2进制信息

zset(sorted set)操作相关
zAdd(key, score, member):向名称为key的zset中添加元素member,score用于排序。如果该元素已经存在,则根据score更新该元素的顺序。
$redis->zAdd('key', 1, 'val1');
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 5, 'val5');
$redis->zRange('key', 0, -1); // array(val0, val1, val5)

zRange(key, start, end, withscores):返回名称为key的zset(元素已按score从小到大排序)中的index从start到end的所有元素
$redis->zAdd('key1', 0, 'val0');
$redis->zAdd('key1', 2, 'val2');
$redis->zAdd('key1', 10, 'val10');
$redis->zRange('key1', 0, -1); // with scores $redis->zRange('key1', 0, -1, true);

zDelete, zRem
zRem(key, member) :删除名称为key的zset中的元素member
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zDelete('key', 'val2');
$redis->zRange('key', 0, -1);

zRevRange(key, start, end, withscores):返回名称为key的zset(元素已按score从大到小排序)中的index从start到end的所有元素.withscores: 是否输出socre的值,默认false,不输出
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zRevRange('key', 0, -1); // with scores $redis->zRevRange('key', 0, -1, true);

zRangeByScore, zRevRangeByScore
$redis->zRangeByScore(key, star, end, array(withscores, limit ));
返回名称为key的zset中score >= star且score < = end的所有元素 zCount $redis->zCount(key, star, end);
返回名称为key的zset中score >= star且score < = end的所有元素的个数 zRemRangeByScore, zDeleteRangeByScore $redis->zRemRangeByScore('key', star, end);
删除名称为key的zset中score >= star且score < = end的所有元素,返回删除个数 zSize, zCard 返回名称为key的zset的所有元素的个数 zScore $redis->zScore(key, val2);
返回名称为key的zset中元素val2的score

zRank, zRevRank
$redis->zRevRank(key, val);
返回名称为key的zset(元素已按score从小到大排序)中val元素的rank(即index,从0开始),若没有val元素,返回“null”。zRevRank 是从大到小排序

zIncrBy
$redis->zIncrBy('key', increment, 'member');
如果在名称为key的zset中已经存在元素member,则该元素的score增加increment;否则向集合中添加该元素,其score的值为increment

zUnion/zInter
参数
keyOutput
arrayZSetKeys
arrayWeights
aggregateFunction Either "SUM", "MIN", or "MAX": defines the behaviour to use on duplicate entries during the zUnion.
对N个zset求并集和交集,并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score,在进行AGGREGATE运算前,都要乘以对于的WEIGHT参数。如果没有提供WEIGHT,默认为1。默认的AGGREGATE是SUM,即结果集合中元素的score是所有集合对应元素进行SUM运算的值,而MIN和MAX是指,结果集合中元素的score是所有集合对应元素中最小值和最大值。

Hash操作
hSet
$redis->hSet('h', 'key1', 'hello');
向名称为h的hash中添加元素key1—>hello

hGet
$redis->hGet('h', 'key1');
返回名称为h的hash中key1对应的value(hello)

hLen
$redis->hLen('h');
返回名称为h的hash中元素个数

hDel
$redis->hDel('h', 'key1');
删除名称为h的hash中键为key1的域

hKeys
$redis->hKeys('h');
返回名称为key的hash中所有键

hVals
$redis->hVals('h')
返回名称为h的hash中所有键对应的value

hGetAll
$redis->hGetAll('h');
返回名称为h的hash中所有的键(field)及其对应的value

hExists
$redis->hExists('h', 'a');
名称为h的hash中是否存在键名字为a的域

hIncrBy
$redis->hIncrBy('h', 'x', 2);
将名称为h的hash中x的value增加2

hMset
$redis->hMset('user:1', array('name' => 'Joe', 'salary' => 2000));
向名称为key的hash中批量添加元素

hMGet
$redis->hmGet('h', array('field1', 'field2'));
返回名称为h的hash中field1,field2对应的value

redis 操作相关
flushDB
清空当前数据库

flushAll
清空所有数据库

randomKey
随机返回key空间的一个key
$key = $redis->randomKey();

select
选择一个数据库
move
转移一个key到另外一个数据库
$redis->select(0); // switch to DB 0
$redis->set('x', '42'); // write 42 to x
$redis->move('x', 1); // move to DB 1
$redis->select(1); // switch to DB 1
$redis->get('x'); // will return 42

rename, renameKey
给key重命名
$redis->set('x', '42');
$redis->rename('x', 'y');
$redis->get('y'); // → 42
$redis->get('x'); // → `FALSE`

renameNx
与remane类似,但是,如果重新命名的名字已经存在,不会替换成功

setTimeout, expire
设定一个key的活动时间(s)
$redis->setTimeout('x', 3);

expireAt
key存活到一个unix时间戳时间
$redis->expireAt('x', time() + 3);

keys, getKeys
返回满足给定pattern的所有key
$keyWithUserPrefix = $redis->keys('user*');

dbSize
查看现在数据库有多少key
$count = $redis->dbSize();

auth
密码认证
$redis->auth('foobared');

bgrewriteaof
使用aof来进行数据库持久化
$redis->bgrewriteaof();

slaveof
选择从服务器
$redis->slaveof('10.0.1.7', 6379);

save
将数据同步保存到磁盘

bgsave
将数据异步保存到磁盘

lastSave
返回上次成功将数据保存到磁盘的Unix时戳

info
返回redis的版本信息等详情

type
返回key的类型值
string: Redis::REDIS_STRING
set: Redis::REDIS_SET
list: Redis::REDIS_LIST
zset: Redis::REDIS_ZSET
hash: Redis::REDIS_HASH
other: Redis::REDIS_NOT_FOUND

本文纯手工打造,转载请标明出处
http://blog.sina.com.cn/s/blog_4b75b0020100neea.html

redis-cli 命令中文版

Redis安装方法、配置手册中文版:redis安装手册,中文配置手册,php-redis模块安装方法,Web管理phpRedisAdmin

Redis提供了丰富的命令(command)对数据库和各种数据类型进行操作,这些command可以在Linux终端使用。在编程时,比如使用Redis 的Java语言包,这些命令都有对应的方法。下面将Redis提供的命令做一总结。

官网命令列表:http://redis.io/commands (英文)
1、连接操作相关的命令

quit:关闭连接(connection)
auth:简单密码认证

2、对value操作的命令

exists(key):确认一个key是否存在
del(key):删除一个key
type(key):返回值的类型
keys(pattern):返回满足给定pattern的所有key
randomkey:随机返回key空间的一个key
rename(oldname, newname):将key由oldname重命名为newname,若newname存在则删除newname表示的key
dbsize:返回当前数据库中key的数目
expire:设定一个key的活动时间(s)
ttl:获得一个key的活动时间
select(index):按索引查询
move(key, dbindex):将当前数据库中的key转移到有dbindex索引的数据库
flushdb:删除当前选择数据库中的所有key
flushall:删除所有数据库中的所有key

3、对String操作的命令

set(key, value):给数据库中名称为key的string赋予值value
get(key):返回数据库中名称为key的string的value
getset(key, value):给名称为key的string赋予上一次的value
mget(key1, key2,…, key N):返回库中多个string(它们的名称为key1,key2…)的value
setnx(key, value):如果不存在名称为key的string,则向库中添加string,名称为key,值为value
setex(key, time, value):向库中添加string(名称为key,值为value)同时,设定过期时间time
mset(key1, value1, key2, value2,…key N, value N):同时给多个string赋值,名称为key i的string赋值value i
msetnx(key1, value1, key2, value2,…key N, value N):如果所有名称为key i的string都不存在,则向库中添加string,名称key i赋值为value i
incr(key):名称为key的string增1操作
incrby(key, integer):名称为key的string增加integer
decr(key):名称为key的string减1操作
decrby(key, integer):名称为key的string减少integer
append(key, value):名称为key的string的值附加value
substr(key, start, end):返回名称为key的string的value的子串

4、对List操作的命令

rpush(key, value):在名称为key的list尾添加一个值为value的元素
lpush(key, value):在名称为key的list头添加一个值为value的 元素
llen(key):返回名称为key的list的长度
lrange(key, start, end):返回名称为key的list中start至end之间的元素(下标从0开始,下同)
ltrim(key, start, end):截取名称为key的list,保留start至end之间的元素
lindex(key, index):返回名称为key的list中index位置的元素
lset(key, index, value):给名称为key的list中index位置的元素赋值为value
lrem(key, count, value):删除count个名称为key的list中值为value的元素。count为0,删除所有值为value的元素,count>0从头至尾删除count个值为value的元素,count<0从尾到头删除|count|个值为value的元素。 lpop(key):返回并删除名称为key的list中的首元素 rpop(key):返回并删除名称为key的list中的尾元素 blpop(key1, key2,… key N, timeout):lpop命令的block版本。即当timeout为0时,若遇到名称为key i的list不存在或该list为空,则命令结束。如果timeout>0,则遇到上述情况时,等待timeout秒,如果问题没有解决,则对keyi+1开始的list执行pop操作。
brpop(key1, key2,… key N, timeout):rpop的block版本。参考上一命令。
rpoplpush(srckey, dstkey):返回并删除名称为srckey的list的尾元素,并将该元素添加到名称为dstkey的list的头部

5、对Set操作的命令

sadd(key, member):向名称为key的set中添加元素member
srem(key, member) :删除名称为key的set中的元素member
spop(key) :随机返回并删除名称为key的set中一个元素
smove(srckey, dstkey, member) :将member元素从名称为srckey的集合移到名称为dstkey的集合
scard(key) :返回名称为key的set的基数
sismember(key, member) :测试member是否是名称为key的set的元素
sinter(key1, key2,…key N) :求交集
sinterstore(dstkey, key1, key2,…key N) :求交集并将交集保存到dstkey的集合
sunion(key1, key2,…key N) :求并集
sunionstore(dstkey, key1, key2,…key N) :求并集并将并集保存到dstkey的集合
sdiff(key1, key2,…key N) :求差集
sdiffstore(dstkey, key1, key2,…key N) :求差集并将差集保存到dstkey的集合
smembers(key) :返回名称为key的set的所有元素
srandmember(key) :随机返回名称为key的set的一个元素

6、对zset(sorted set)操作的命令

zadd(key, score, member):向名称为key的zset中添加元素member,score用于排序。如果该元素已经存在,则根据score更新该元素的顺序。
zrem(key, member) :删除名称为key的zset中的元素member
zincrby(key, increment, member) :如果在名称为key的zset中已经存在元素member,则该元素的score增加increment;否则向集合中添加该元素,其score的值为increment
zrank(key, member) :返回名称为key的zset(元素已按score从小到大排序)中member元素的rank(即index,从0开始),若没有member元素,返回“nil”
zrevrank(key, member) :返回名称为key的zset(元素已按score从大到小排序)中member元素的rank(即index,从0开始),若没有member元素,返回“nil”
zrange(key, start, end):返回名称为key的zset(元素已按score从小到大排序)中的index从start到end的所有元素
zrevrange(key, start, end):返回名称为key的zset(元素已按score从大到小排序)中的index从start到end的所有元素
zrangebyscore(key, min, max):返回名称为key的zset中score >= min且score < = max的所有元素 zcard(key):返回名称为key的zset的基数 zscore(key, element):返回名称为key的zset中元素element的score zremrangebyrank(key, min, max):删除名称为key的zset中rank >= min且rank < = max的所有元素 zremrangebyscore(key, min, max) :删除名称为key的zset中score >= min且score < = max的所有元素 zunionstore / zinterstore(dstkeyN, key1,…,keyN, WEIGHTS w1,…wN, AGGREGATE SUM|MIN|MAX):对N个zset求并集和交集,并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score,在进行AGGREGATE运算前,都要乘以对于的WEIGHT参数。如果没有提供WEIGHT,默认为1。默认的AGGREGATE是SUM,即结果集合中元素的score是所有集合对应元素进行SUM运算的值,而MIN和MAX是指,结果集合中元素的score是所有集合对应元素中最小值和最大值。 7、对Hash操作的命令 hset(key, field, value):向名称为key的hash中添加元素field<—>value
hget(key, field):返回名称为key的hash中field对应的value
hmget(key, field1, …,field N):返回名称为key的hash中field i对应的value
hmset(key, field1, value1,…,field N, value N):向名称为key的hash中添加元素field i< —>value i
hincrby(key, field, integer):将名称为key的hash中field的value增加integer
hexists(key, field):名称为key的hash中是否存在键为field的域
hdel(key, field):删除名称为key的hash中键为field的域
hlen(key):返回名称为key的hash中元素个数
hkeys(key):返回名称为key的hash中所有键
hvals(key):返回名称为key的hash中所有键对应的value
hgetall(key):返回名称为key的hash中所有的键(field)及其对应的value

8、持久化

save:将数据同步保存到磁盘
bgsave:将数据异步保存到磁盘
lastsave:返回上次成功将数据保存到磁盘的Unix时戳
shundown:将数据同步保存到磁盘,然后关闭服务

9、远程服务控制

info:提供服务器的信息和统计
monitor:实时转储收到的请求
slaveof:改变复制策略设置
config:在运行时配置Redis服务器

ThinkPHP+Redis 缓存类

为了让ThinkPHP支持Redis,写了这个Redis的缓存类,里面只有简单的Get和Set方法,方便在S方法直接使用,复杂的使用方法,可以直接使用phpRedis。

本类要求支持phpRedis安装方法:http://www.4wei.cn/archives/1001521

在TP项目中的路径

ThinkPATH\Lib\Think\Util\Cache\CacheRedis.class.php

Extend\Driver\Cache\CacheRedis.class.php

配置方法,在ThinkPHP项目配置文件中,添加以下参数:

	/* 系统缓存 */
	'DATA_CACHE_TYPE'					=> 'Redis',
	'REDIS_HOST'						=> '192.168.0.243',
	'REDIS_PORT'						=> 6379,
	'DATA_CACHE_TIME'					=> 3600,

上述参数分别表示缓存类型,主机,端口和超时时间。

附件下载:CacheRedis.class SVN中已经更新
源码如下:

<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2012 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: 尘缘 <130775@qq.com>
// +----------------------------------------------------------------------
// $Id: CacheRedis.class.php 2728 2012-02-12 04:12:51Z liu21st $

/**
 +-------------------------------------
 * CacheRedis缓存驱动类
 * 要求安装phpredis扩展:https://github.com/owlient/phpredis
 +-------------------------------------
 */
class CacheRedis extends Cache {

    /**
     +----------------------------------------------------------
     * 架构函数
     +----------------------------------------------------------
     * @access public
     +----------------------------------------------------------
     */
    public function __construct($options='') {
        if ( !extension_loaded('redis') ) {
            throw_exception(L('_NOT_SUPPERT_').':redis');
        }
        if(empty($options)) {
            $options = array (
                'host'  => C('REDIS_HOST') ? C('REDIS_HOST') : '127.0.0.1',
                'port'  => C('REDIS_PORT') ? C('REDIS_PORT') : 6379,
                'timeout' => C('DATA_CACHE_TIMEOUT') ? C('DATA_CACHE_TIMEOUT') : false,
                'persistent' => false,
                'expire'   => C('DATA_CACHE_TIME'),
                'length'   => 0,
            );
        }
        $this->options =  $options;
        $func = $options['persistent'] ? 'pconnect' : 'connect';
        $this->handler  = new Redis;
        $this->connected = $options['timeout'] === false ?
            $this->handler->$func($options['host'], $options['port']) :
            $this->handler->$func($options['host'], $options['port'], $options['timeout']);
    }

    /**
     +----------------------------------------------------------
     * 是否连接
     +----------------------------------------------------------
     * @access private
     +----------------------------------------------------------
     * @return boolen
     +----------------------------------------------------------
     */
    private function isConnected() {
        return $this->connected;
    }

    /**
     +----------------------------------------------------------
     * 读取缓存
     +----------------------------------------------------------
     * @access public
     +----------------------------------------------------------
     * @param string $name 缓存变量名
     +----------------------------------------------------------
     * @return mixed
     +----------------------------------------------------------
     */
    public function get($name) {
        N('cache_read',1);
        return $this->handler->get($name);
    }

    /**
     +----------------------------------------------------------
     * 写入缓存
     +----------------------------------------------------------
     * @access public
     +----------------------------------------------------------
     * @param string $name 缓存变量名
     * @param mixed $value  存储数据
     * @param integer $expire  有效时间(秒)
     +----------------------------------------------------------
     * @return boolen
     +----------------------------------------------------------
     */
    public function set($name, $value, $expire = null) {
        N('cache_write',1);
        if(is_null($expire)) {
            $expire  =  $this->options['expire'];
        }
        if(is_int($expire)) {
            $result = $this->handler->setex($name, $expire, $value);
        }else{
            $result = $this->handler->set($name, $value);
        }
        if($result && $this->options['length']>0) {
            // 记录缓存队列
            $this->queue($name);
        }
        return $result;
    }

    /**
     +----------------------------------------------------------
     * 删除缓存
     *
     +----------------------------------------------------------
     * @access public
     +----------------------------------------------------------
     * @param string $name 缓存变量名
     +----------------------------------------------------------
     * @return boolen
     +----------------------------------------------------------
     */
    public function rm($name) {
        return $this->handler->delete($name);
    }

    /**
     +----------------------------------------------------------
     * 清除缓存
     +----------------------------------------------------------
     * @access public
     +----------------------------------------------------------
     * @return boolen
     +----------------------------------------------------------
     */
    public function clear() {
        return $this->handler->flushDB();
    }
}

redis安装手册,中文配置手册,php-redis模块安装方法,Web管理phpRedisAdmin

redis官方网站及最新版本下载地址:http://redis.io/download
本文章基于Centos+yum安装的服务器环境

redis的下载及安装:

mkdir /usr/local/redis
cd /usr/local/redis
wget http://redis.googlecode.com/files/redis-2.4.2.tar.gz
tar xzf redis-2.4.2.tar.gz
cd redis-2.4.2
make
src/redis-server

redis测试命令:

src/redis-cli
redis> set foo bar
OK
redis> get foo
“bar”;

接下来需要进行redis配置:

daemonize yes
pidfile /usr/local/redis/var/redis.pid
port 6379
timeout 300
loglevel verbose
logfile /usr/local/redis/var/redis.log
databases 16
save 900 1
save 300 10
save 60 10000
rdbcompression yes
dbfilename dump.rdb
dir /usr/local/redis/var
slave-serve-stale-data yes
appendonly no
appendfsync everysec
no-appendfsync-on-rewrite no
vm-enabled no
vm-swap-file /tmp/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
activerehashing yes

Redis中文配置文档:
1,是否以后台进程运行,默认为no,生产环境中肯定要设置成yes,并设置为自动启动
daemonize no
2,如以后台进程运行,则需指定一个pid,默认为/var/run/redis.pid
pidfile /var/run/redis.pid
3,监听端口,默认为6379
port 6379
4,绑定主机IP,默认值为127.0.0.1(注释),生产环境中一般是内外网的IP
bind 127.0.0.1
5,超时时间,默认为300(秒)
timeout 300
6,日志记录等级,有4个可选值,debug,verbose(默认值),notice,warning
loglevel verbose
7,日志记录方式,默认值为stdout
logfile stdout
8,可用数据库数,默认值为16,默认数据库为0
databases 16
9,指出在多长时间内,有多少次更新操作,就将数据同步到数据文件。这个可以多个条件配合,比如默认配置文件中的设置,就设置了三个条件。
900秒(15分钟)内至少有1个key被改变
save 900 1
300秒(5分钟)内至少有10个key被改变
save 300 10
10,存储至本地数据库时是否压缩数据,默认为yes
rdbcompression yes
11,本地数据库文件名,默认值为dump.rdb
dbfilename /root/redis_db/dump.rdb
12,本地数据库存放路径,默认值为 ./
dir /root/redis_db/
13,当本机为从服务时,设置主服务的IP及端口(注释)
slaveof
14,当本机为从服务时,设置主服务的连接密码(注释)
masterauth
15,连接密码(注释)
requirepass foobared
16,最大客户端连接数,默认不限制(注释)
maxclients 128
17,设置最大内存,达到最大内存设置后,Redis会先尝试清除已到期或即将到期的Key,当此方法处理后,任到达最大内存设置,将无法再进行写入操作。(注释)
maxmemory
18,是否在每次更新操作后进行日志记录,如果不开启,可能会在断电时导致一段时间内的数据丢失。因为redis本身同步数据文件是按上面save条件来同步的,所以有的数据会在一段时间内只存在于内存中。默认值为no
appendonly yes
19,更新日志文件名,默认值为appendonly.aof(注释)
appendfilename /root/redis_db/appendonly.aof
20,更新日志条件,共有3个可选值。no表示等操作系统进行数据缓存同步到磁盘,always表示每次更新操作后手动调用fsync()将数据写到磁盘,everysec表示每秒同步一次(默认值)。
appendfsync everysec
21,是否使用虚拟内存,默认值为no
vm-enabled yes
22,虚拟内存文件路径,默认值为/tmp/redis.swap,不可多个Redis实例共享
vm-swap-file /tmp/redis.swap
23,将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的 (Redis的索引数据就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0。
vm-max-memory 0
24,虚拟内存文件以块存储,每块32bytes
vm-page-size 32
25,虚拟内在文件的最大数
vm-pages 134217728
26,可以设置访问swap文件的线程数,设置最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的.可能会造成比较长时间的延迟,但是对数据完整性有很好的保证.
vm-max-threads 4
27,把小的输出缓存放在一起,以便能够在一个TCP packet中为客户端发送多个响应,具体原理和真实效果我不是很清楚。所以根据注释,你不是很确定的时候就设置成yes
glueoutputbuf yes
28,在redis 2.0中引入了hash数据结构。当hash中包含超过指定元素个数并且最大的元素没有超过临界时,hash将以一种特殊的编码方式(大大减少内存使用)来存储,这里可以设置这两个临界值
hash-max-zipmap-entries 64
29,hash中一个元素的最大值
hash-max-zipmap-value 512
30,开启之后,redis将在每100毫秒时使用1毫秒的CPU时间来对redis的hash表进行重新hash,可以降低内存的使用。当你的使 用场景中,有非常严格的实时性需要,不能够接受Redis时不时的对请求有2毫秒的延迟的话,把这项配置为no。如果没有这么严格的实时性要求,可以设置 为yes,以便能够尽可能快的释放内存
activerehashing yes

启动Redis-Server:
可以直接运行Redis-Server,也可以配置成后台服务启动,我做了一个启动脚本方便管理

vim /etc/init.d/redis.sh
#!/bin/bash
/usr/local/redis/src/redis-server /usr/local/redis/redis.conf
chmo
/etc/init.d/redis.sh

php-Redis模块安装:
发布主页:https://github.com/nicolasff/phpredis,以前在:https://github.com/owlient/phpredis,github上使用wget需要使用--no-check-certificate。
生产环境中增加php扩展需要使用phpize,一些基础文档在这里:http://blog.51yip.com/php/177.html
如果你的机器上没有phpize,则需要先安装php-devel这个包。

yum install php-devel

下载安装phpredis过程:

cd /usr/include/php/ext
wget --no-check-certificate http://github.com/owlient/phpredis/tarball/master -O phpredis.tar.gz
tar zxvf phpredis.tar.gz
cd phpredis*
phpize
./configure
make
make install

成功后,模块会被安装到系统上:

Installing shared extensions:     /usr/lib64/php/modules/
ls /usr/lib64/php/modules/
dbase.so  eaccelerator.so  gd.so  json.so  memcache.so  mysqli.so  mysql.so  pdo_mysql.so  pdo.so  pdo_sqlite.so  phpcups.so  redis.so  zip.so

然后在php.ini中添加模块并启用,redis.so:

extension=/usr/lib64/php/modules/redis.so

最后重启webServer即可。

Redis的界面管理工具,有过传统LAMP经验的同学肯定都对phpmyadmin非常熟悉,phpmyadmin是一个PHP的MySQL WEB管理工具,非常实用也非常好用。而phpRedisAdmin从名字上就可得知,它是一个PHP版的Redis WEB可视化管理软件。
https://github.com/ErikDubbelboer/phpRedisAdmin/downloads
下载以后,放到Web目录就可以运行。不过我发现这个项目调用的Jqery使用了Google CDN,速度是非常慢呐。我给换成微软的jQuery CDN,唉。
http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.6.2.min.js

本文的重点在于需要使用phpize进行模块的安装。
同时,本博后期可能会添加ThinkPHP+Redis的缓存类,目前正在研究Redis的高级用法。

ThinkPHP + Redis延迟写入,第一篇,Redis安装、配置解析

Redis 源码编译安装:

$ wget http://redis.googlecode.com/files/redis-2.8.12.tar.gz
$ tar xzvf redis-2.8.12.tar.gz
$ cd redis-2.8.12
$ make
$ make install
 
# 修改完配置文件后,启动Redis
$ redis-server /etc/redis.conf

Note:

make install会将生成的可执行程序复制到/usr/local/bin目录中
解压后,源码目录中有一个默认配置文件,备份这个文件后,在此基础上修改后,复制到/etc/redis.conf,或其他你想要放置的目录

MacOS安装

brew install redis
pecl install redis

centos安装

brew install redis
pecl install redis

参数详解:

#是否以后台进程运行
daemonize yes
 
#指定后台进程的pid文件写入位置
pidfile /var/run/redis.pid
 
#监听端口,默认为6379
port 6379
 
#只接受以下绑定的IP请求
bind 127.0.0.1
 
设置unix套接字,默认为空,及不通过unix套接字来监听
# unixsocket /tmp/redis.sock
# unixsocketperm 755
 
#客户端空闲多长时间,关闭链接。0表示不关闭
timeout 5
 
# TCP keepalive.
# 如果是非零值,当失去链接时,会使用SO_KEEPALIVE发送TCP ACKs 到客户端。
# 这个参数有两个作用:
# 1.检测断点。
# 2.从网络中间设备来看,就是保持链接
# 在Linux上,设定的时间就是发送ACKs的周期。
# 注意:达到双倍的设定时间才会关闭链接。在其他内核上,周期依赖于内核设置。
# 一个比较合理的值为60s
tcp-keepalive 0
 
# 指定日志级别,以下记录信息依次递减
# debug用于开发/测试
# verbose没debug那么详细
# notice适用于生产线# warning只记录非常重要的信息
loglevel notice
 
#日志文件名称,如果为stdout则输出到标准输出端,如果是以后台进程运行则不产生日志
logfile /data/logs/redis/redis.log
 
# 要想启用系统日志记录器,设置一下选项为yes
# syslog-enabled no
 
# 指明syslog身份
# syslog-ident redis
 
# 指明syslog设备。必须是一个用户或者是local0 ~ local7之一
# syslog-facility local0
 
#设置数据库数目,第一个数据库编号为:0
databases 16
 
##############快照#################
 
#在什么条件下保存数据库到磁盘,条件可以有很多个,满足任何一个条件都会精心快照
#在900秒之内有一次key的变化
save 900 1
#在300秒之内,有10个key的变化
save 300 10
#在60秒之内有10000个key变化
save 60 10000
 
#当持久化失败的时候,是否继续提供服务
stop-writes-on-bgsave-error yes
 
#当写入磁盘时,是否使用LZF算法压缩数据,默认为yes
rdbcompression yes
 
#是否添加CRC64校验到每个文件末尾--花费时间保证安全
rdbchecksum yes
 
#磁盘上数据库的保存名称
dbfilename dump.rdb
 
# Redis工作目录,以上数据库保存文件和AOF日志都会写入此目录
dir /data/redis
 
##############同步#################
 
#主从复制,当本机是slave时配置
# slaveof <masterip> <masterport>
 
#当主机需要密码验证时候配置
# masterauth <master -password>
 
# 当slave和master丢失链接,或正处于同步过程中。是否响应客户端请求
# 设置为yes表示响应
# 设置为no,直接返回"SYNC with master in progress"(正在和主服务器同步中)
slave-serve-stale-data yes
 
# 设置slave是否为只读。
# 注意:即使slave设置为只读,也不能令其暴露在不受信任的网络环境中
slave-read-only yes
 
# 设置slave给master发送ping的时间间隔
# repl-ping-slave-period 10
 
# 设置数据传输I/O,主机数据、ping响应超时时间,默认60s
# 这个时间一定要比repl-ping-slave-period大,否则会不断检测到超时
# repl-timeout 60
 
# 是否在SYNC后slave socket上禁用TCP_NODELAY?
# 如果你设置为yes,Redis会使用少量TCP报文和少量带宽发送数据给slave。
# 但是这样会在slave端出现延迟。如果使用Linux内核的默认设置,大概40毫秒。
# 如果你设置为no,那么在slave端研究就会减少但是同步带宽要增加。
# 默认我们是为低延迟优化的。
# 但是如果流量特别大或者主从服务器相距比较远,设置为yes比较合理。
repl-disable-tcp-nodelay no
 
# 设置slave优先级,默认为100
# 当主服务器不能正确工作的时候,数字低的首先被提升为主服务器,但是0是禁用选择
slave-priority 100
 
##############安全#################
 
# 设置客户端连接密码,因为Redis响应速度可以达到每秒100w次,所以密码要特别复杂
# requirepass foobared
 
# 命令重新命名,或者禁用。
# 重命名命令为空字符串可以禁用一些危险命令比如:FLUSHALL删除所有数据
# 需要注意的是,写入AOF文件或传送给slave的命令别名也许会引起一些问题
# rename-command CONFIG ""
 
##############限制#################
 
# 设置最多链接客户端数量,默认为10000。
# 实际可以接受的请求数目为设置值减去32,这32是Redis为内部文件描述符保留的
# maxclients 10000
 
# 设置最大使用内存数量,在把Redis当作LRU缓存时特别有用。
# 设置的值要比系统能使用的值要小
# 因为当启用删除算法时,slave输出缓存也要占用内存
# maxmemory <bytes>
 
#达到最大内存限制时,使用何种删除算法
# volatile-lru  使用LRU算法移除带有过期标致的key
# allkeys-lru -> 使用LRU算法移除任何key
# volatile-random -> 随机移除一个带有过期标致的key
# allkeys-random ->  随机移除一个key
# volatile-ttl -> 移除最近要过期的key
# noeviction -> 不删除key,当有写请求时,返回错误
#默认设置为volatile-lru
# maxmemory-policy volatile-lru
 
# LRU和最小TTL算法没有精确的实现
# 为了节省内存只在一个样本范围内选择一个最近最少使用的key,可以设置这个样本大小
# maxmemory-samples 3
 
##############AO模式#################
 
# AOF和RDB持久化可以同时启用
# Redis启动时候会读取AOF文件,AOF文件有更好的持久化保证
appendonly no
 
# AOF的保存名称,默认为appendonly.aof
# appendfilename appendonly.aof
 
# 设置何时写入追加日志,又三种模式
# no:表示由操作系统决定何时写入。性能最好,但可靠性最低
# everysec:表示每秒执行一次写入。折中方案,推荐
# always:表示每次都写入磁盘。性能最差,比上面的安全一些
appendfsync everysec
 
# 当AOF同步策略设定为alway或everysec
# 当后台存储进程(后台存储或者AOF日志后台写入)会产生很多磁盘开销
# 某些Linux配置会使Redis因为fsync()调用产生阻塞很久
# 现在还没有修复补丁,甚至使用不同线程进行fsync都会阻塞我们的同步write(2)调用。
# 为了缓解这个问题,使用以下选项在一个BGSAVE或BGREWRITEAOF运行的时候
# 可以阻止fsync()在主程序中被调用,
no-appendfsync-on-rewrite no
 
# AOF自动重写(合并命令,减少日志大小)
# 当AOF日志大小增加到一个特定比率,Redis调用BGREWRITEAOF自动重写日志文件
# 原理:Redis 会记录上次重写后AOF文件的文件大小。
# 如果刚启动,则记录启动时AOF大小
# 这个基本大小会用来和当前大小比较。如果当前大小比特定比率大,就会触发重写。
# 你也需要指定一个AOF需要被重写的最小值,这样会避免达到了比率。
# 但是AOF文件还很小的情况下重写AOF文件。
# 设置为0禁用自动重写
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
 
##############LUA脚本#################
# Lua脚本的最大执行时间,单位毫秒
# 超时后会报错,并且计入日志
# 当一个脚本运行时间超过了最大执行时间
# 只有SCRIPT KILL和 SHUTDOWN NOSAVE两个命令可以使用。
# SCRIPT KILL用于停止没有调用写命令的脚本。
# SHUTDOWN NOSAVE是唯一的一个,在脚本的写命令正在执行
# 用户又不想等待脚本的正常结束的情况下,关闭服务器的方法。
# 以下选项设置为0或负数就会取消脚本执行时间限制
lua-time-limit 5000
 
##############慢查询#################
 
# Redis慢查询日志记录超过设定时间的查询,且只记录执行命令的时间
# 不记录I/O操作,比如:和客户端交互,发送回复等。
# 时间单位为微妙,1000000微妙 = 1 秒
# 设置为负数会禁用慢查询日志,设置为0会记录所有查询命令
slowlog-log-slower-than 10000
 
# 日志长度没有限制,但是会消耗内存。超过日志长度后,最旧的记录会被移除
# 使用SLOWLOG RESET命令可以回收内存
slowlog-max-len 128
 
##############高级设置###############
 
# 当有少量条目的时候,哈希使用高效内存数据结构。最大的条目也不能超过设定的阈值。# “少量”定义如下:
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
 
# 和哈希编码一样,少量列表也以特殊方式编码节省内存。“少量”设定如下:
list-max-ziplist-entries 512
list-max-ziplist-value 64
 
# 集合只在以下情况下使用特殊编码来节省内存
# -->集合全部由64位带符号10进制整数构成的字符串组成
# 下面的选项设置这个特殊集合的大小。
set-max-intset-entries 512
 
# 当有序集合的长度和元素设定为以下数字时,又特殊编码节省内存
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
 
# 哈希刷新使用每100个CPU毫秒中的1毫秒来帮助刷新主哈希表(顶级键值映射表)。
#  Redis哈希表使用延迟刷新机制,越多操作,越多刷新。
# 如果服务器空闲,刷新操作就不会进行,更多内存会被哈希表占用
# 默认每秒进行10次主字典刷新,释放内存。
# 如果你有硬性延迟需求,偶尔2毫秒的延迟无法忍受的话。设置为no
# 否则设置为yes
activerehashing yes
 
# 客户端输出缓存限制强迫断开读取速度比较慢的客户端
# 有三种类型的限制
# normal -> 正茶馆你客户端
# slave  -> slave和 MONITOR
# pubsub -> 客户端至少订阅了一个频道或者模式
# 客户端输出缓存限制语法如下(时间单位:秒)
# client-output-buffer-limit < 类别> < 强制限制> < 软性限制> < 软性时间>
# 达到强制限制缓存大小,立刻断开链接。
# 达到软性限制,仍然会有软性时间大小的链接时间
# 默认正常客户端无限制,只有请求后,异步客户端数据请求速度快于它能读取数据的速度
# 订阅模式和主从客户端又默认限制,因为它们都接受推送。
# 强制限制和软性限制都可以设置为0来禁用这个特性
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
 
# 设置Redis后台任务执行频率,比如清除过期键任务。
# 设置范围为1到500,默认为10.越大CPU消耗越大,延迟越小。
# 建议不要超过100
hz 10
 
# 当子进程重写AOF文件,以下选项开启时,AOF文件会每产生32M数据同步一次。
# 这有助于更快写入文件到磁盘避免延迟
aof-rewrite-incremental-fsync yes
 
##############包含#################
 
#引入标准模板
# include /path/to/other.conf

启动redis-server

redis-server /usr/local/etc/redis.conf &

php-redis demo code

$r = new redis();
$r->connect("127.0.0.1", 6379);
print_r($r->get("a"));
print_r($r->set("a", "bingo"));
print_r($r->get("a"));