1626人阅读
laravel（2）
predis是php连接redis的操作库，由于它完全使用php编写，大量使用命名空间以及闭包等功能，只支持php5.3以上版本，故实测性能一般，每秒25000次读写，相信改换c语言编写的php扩展后性能会大幅提升(比如使用C扩展phpredis&)。
将session数据存放到redis也很简单:
session.save_handler = redis
session.save_path = &tcp://127.0.0.1:6379&
//使用autoload加载相关库,这边重点就是为了require $
spl_autoload_register ( function ( $class )
= __DIR__ . '/lib/Predis/' . $class . '.php' ;
( file_exists ( $file ) )
//配置连接的IP、端口、以及相应的数据库
'127.0.0.1' ,
'database'
new Client ( $server ) ;
//普通set/get操作
$redis -& set ( 'library' ,
'predis' ) ;
$redis -& get ( 'library' ) ;
//显示 'predis'
//setex set一个存储时效
$redis -& setex ( 'str' ,
//表示存储有效期为10秒
//setnx/msetnx相当于add操作,不会覆盖已有值
$redis -& setnx ( 'foo' , 12 ) ;
$redis -& setnx ( 'foo' , 34 ) ;
//getset操作,set的变种,结果返回替换前的值
$redis -& getset ( 'foo' , 56 ) ; //返回34
// incrby/incr/decrby/decr 对值的递增和递减
$redis -& incr ( 'foo' ) ;
$redis -& incrby ( 'foo' , 2 ) ;
//exists检测是否存在某值
$redis -& exists ( 'foo' ) ; //true
//del 删除
$redis -& del ( 'foo' ) ; //true
//type 类型检测,字符串返回string,列表返回 list,set表返回set/zset,hash表返回hash
$redis -& type ( 'foo' ) ; //不存在,返回none
$redis -& set ( 'str' , 'test' ) ;
$redis -& type ( 'str' ) ;
//字符串，返回string
//append 连接到已存在字符串
$redis -& append ( 'str' , '_123' ) ;
//返回累加后的字符串长度8,此进str为 'test_123'
//setrange 部分替换操作
$redis -& setrange ( 'str' , 0 , 'abc' ) ;
//返回3,参数2为0时等同于set操作
$redis -& setrange ( 'str' , 2 , 'cd' ) ; //返回4,表示从第2个字符后替换,这时'str'为'abcd'
//substr 部分获取操作
$redis -& substr ( 'str' , 0 , 2 ) ; //表示从第0个起，取到第2个字符，共3个，返回'abc'
//strlen 获取字符串长度
$redis -& strlen ( 'str' ) ;
//setbit/getbit 位存储和获取
$redis -& setbit ( 'binary' , 31 , 1 ) ;
//表示在第31位存入1,这边可能会有大小端问题?不过没关系,getbit 应该不会有问题
$redis -& getbit ( 'binary' , 31 ) ;
//keys 模糊查找功能,支持*号以及?号(匹配一个字符)
$redis -& set ( 'foo1' , 123 ) ;
$redis -& set ( 'foo2' , 456 ) ;
$redis -& keys ( 'foo*' ) ;
//返回foo1和foo2的array
$redis -& keys ( 'f?o?' ) ;
//randomkey 随机返回一个key
$redis -& randomkey ( ) ;
//可能是返回 'foo1'或者是'foo2'及其它任何一存在redis的key
//rename/renamenx 对key进行改名,所不同的是renamenx不允许改成已存在的key
$redis -& rename ( 'str' , 'str2' ) ;
//把原先命名为'str'的key改成了'str2'
//expire 设置key-value的时效性,ttl 获取剩余有效期,persist 重新设置为永久存储
$redis -& expire ( 'foo' ,
//设置有效期为1秒
$redis -& ttl ( 'foo' ) ;
//返回有效期值1s
$redis -& expire ( 'foo' ) ;
//取消expire行为
//dbsize 返回redis当前数据库的记录总数
$redis -& dbsize ( ) ;
//rpush/rpushx 有序列表操作,从队列后插入元素
//lpush/lpushx 和rpush/rpushx的区别是插入到队列的头部,同上,'x'含义是只对已存在的key进行操作
$redis -& rpush ( 'fooList' ,
'bar1' ) ;
//返回一个列表的长度1
$redis -& lpush ( 'fooList' ,
'bar0' ) ;
//返回一个列表的长度2
$redis -& rpushx ( 'fooList' ,
'bar2' ) ;
//返回3,rpushx只对已存在的队列做添加,否则返回0
//llen返回当前列表长度
$redis -& llen ( 'fooList' ) ; //3
//lrange 返回队列中一个区间的元素
$redis -& lrange ( 'fooList' , 0 , 1 ) ;
//返回数组包含第0个至第1个共2个元素
$redis -& lrange ( 'fooList' , 0 ,- 1 ) ; //返回第0个至倒数第一个,相当于返回所有元素,注意redis中很多时候会用到负数,下同
//lindex 返回指定顺序位置的list元素
$redis -& lindex ( 'fooList' , 1 ) ;
//返回'bar1'
//lset 修改队列中指定位置的value
$redis -& lset ( 'fooList' , 1 , '123' ) ; //修改位置1的元素,返回true
//lrem 删除队列中左起指定数量的字符
$redis -& lrem ( 'fooList' , 1 , '_' ) ;
//删除队列中左起(右起使用-1)1个字符'_'(若有)
//lpop/rpop 类似栈结构地弹出(并删除)最左或最右的一个元素
$redis -& lpop ( 'fooList' ) ;
$redis -& rpop ( 'fooList' ) ;
//ltrim 队列修改，保留左边起若干元素，其余删除
$redis -& ltrim ( 'fooList' ,
//保留左边起第0个至第1个元素
//rpoplpush 从一个队列中pop出元素并push到另一个队列
$redis -& rpush ( 'list1' , 'ab0' ) ;
$redis -& rpush ( 'list1' , 'ab1' ) ;
$redis -& rpush ( 'list2' , 'ab2' ) ;
$redis -& rpush ( 'list2' , 'ab3' ) ;
$redis -& rpoplpush ( 'list1' , 'list2' ) ; //结果list1 =&array('ab0'),list2 =&array('ab1','ab2','ab3')
$redis -& rpoplpush ( 'list2' , 'list2' ) ; //也适用于同一个队列,把最后一个元素移到头部list2 =&array('ab3','ab1','ab2')
//linsert 在队列的中间指定元素前或后插入元素
$redis -& linsert ( 'list2' ,
'before' , 'ab1' , '123' ) ;
//表示在元素'ab1'之前插入'123'
$redis -& linsert ( 'list2' ,
'after' , 'ab1' , '456' ) ;
//表示在元素'ab1'之后插入'456'
//blpop/brpop 阻塞并等待一个列队不为空时，再pop出最左或最右的一个元素（这个功能在php以外可以说非常好用）
//brpoplpush 同样是阻塞并等待操作，结果同rpoplpush一样
$redis -& blpop ( 'list3' , 10 ) ;
//如果list3为空则一直等待,直到不为空时将第一元素弹出,10秒后超时
//sadd 增加元素,返回true,重复返回false
$redis -& sadd ( 'set1' , 'ab' ) ;
$redis -& sadd ( 'set1' , 'cd' ) ;
$redis -& sadd ( 'set1' , 'ef' ) ;
//srem 移除指定元素
$redis -& srem ( 'set1' , 'cd' ) ;
//删除'cd'元素
//spop 弹出首元素
$redis -& spop ( 'set1' ) ;
//smove 移动当前set表的指定元素到另一个set表
$redis -& sadd ( 'set2' , '123' ) ;
$redis -& smove ( 'set1' , 'set2' , 'ab' ) ; //移动'set1'中的'ab'到'set2',返回true or false
//scard 返回当前set表元素个数
$redis -& scard ( 'set2' ) ; //2
//sismember 判断元素是否属于当前表
$redis -& sismember ( 'set2' , '123' ) ;
//true or false
//smembers 返回当前表的所有元素
$redis -& smembers ( 'set2' ) ;
//array('123','ab');
//sinter/sunion/sdiff
返回两个表中元素的交集/并集/补集
$redis -& sadd ( 'set1' , 'ab' ) ;
$redis -& sinter ( 'set2' , 'set1' ) ;
//返回array('ab')
//sinterstore/sunionstore/sdiffstore 将两个表交集/并集/补集元素copy到第三个表中
$redis -& set ( 'foo' , 0 ) ;
$redis -& sinterstore ( 'foo' , 'set1' ) ;
//这边等同于将'set1'的内容copy到'foo'中，并将'foo'转为set表
$redis -& sinterstore ( 'foo' , array ( 'set1' , 'set2' ) ) ;
//将'set1'和'set2'中相同的元素copy到'foo'表中,覆盖'foo'原有内容
//srandmember 返回表中一个随机元素
$redis -& srandmember ( 'set1' ) ;
有序set表操作
//sadd 增加元素,并设置序号,返回true,重复返回false
$redis -& zadd ( 'zset1' , 1 , 'ab' ) ;
$redis -& zadd ( 'zset1' , 2 , 'cd' ) ;
$redis -& zadd ( 'zset1' , 3 , 'ef' ) ;
//zincrby 对指定元素索引值的增减,改变元素排列次序
$redis -& zincrby ( 'zset1' , 10 , 'ab' ) ; //返回11
//zrem 移除指定元素
$redis -& zrem ( 'zset1' , 'ef' ) ;
//true or false
//zrange 按位置次序返回表中指定区间的元素
$redis -& zrange ( 'zset1' , 0 , 1 ) ;
//返回位置0和1之间(两个)的元素
$redis -& zrange ( 'zset1' , 0 ,- 1 ) ; //返回位置0和倒数第一个元素之间的元素(相当于所有元素)
//zrevrange 同上,返回表中指定区间的元素,按次序倒排
$redis -& zrevrange ( 'zset1' , 0 ,- 1 ) ;
//元素顺序和zrange相反
//zrangebyscore/zrevrangebyscore 按顺序/降序返回表中指定索引区间的元素
$redis -& zadd ( 'zset1' , 3 , 'ef' ) ;
$redis -& zadd ( 'zset1' , 5 , 'gh' ) ;
$redis -& zrangebyscore ( 'zset1' , 2 , 9 ) ;
//返回索引&#之间的元素 array('ef','gh')
//参数形式
$redis -& zrangebyscore ( 'zset1' , 2 , 9 , 'withscores' ) ;
//返回索引&#之间的元素并包含索引值 array(array('ef',3),array('gh',5))
$redis -& zrangebyscore ( 'zset1' , 2 , 9 , array ( 'withscores'
=& true , 'limit' =& array ( 1 ,
//返回索引&#之间的元素,'withscores' =&true表示包含索引值; 'limit'=&array(1, 2),表示最多返回2条,结果为array(array('ef',3),array('gh',5))
//zunionstore/zinterstore 将多个表的并集/交集存入另一个表中
$redis -& zunionstore ( 'zset3' , array ( 'zset1' , 'zset2' , 'zset0' ) ) ;
//将'zset1','zset2','zset0'的并集存入'zset3'
//其它参数
$redis -& zunionstore ( 'zset3' , array ( 'zset1' , 'zset2' ) , array ( 'weights'
array ( 5 , 0 ) ) ) ; //weights参数表示权重，其中表示并集后值大于5的元素排在前，大于0的排在后
$redis -& zunionstore ( 'zset3' , array ( 'zset1' , 'zset2' ) , array ( 'aggregate'
'max' ) ) ; //'aggregate' =& 'max'或'min'表示并集后相同的元素是取大值或是取小值
//zcount 统计一个索引区间的元素个数
$redis -& zcount ( 'zset1' , 3 , 5 ) ; //2
$redis -& zcount ( 'zset1' , '(3' , 5 ) ) ;
//'(3'表示索引值在3-5之间但不含3,同理也可以使用'(5'表示上限为5但不含5
//zcard 统计元素个数
$redis -& zcard ( 'zset1' ) ; //4
//zscore 查询元素的索引
$redis -& zscore ( 'zset1' , 'ef' ) ; //3
//zremrangebyscore 删除一个索引区间的元素
$redis -& zremrangebyscore ( 'zset1' , 0 , 2 ) ;
//删除索引在0-2之间的元素('ab','cd'),返回删除元素个数2
//zrank/zrevrank 返回元素所在表顺序/降序的位置(不是索引)
$redis -& zrank ( 'zset1' , 'ef' ) ; //返回0,因为它是第一个元素;zrevrank则返回1(最后一个)
//zremrangebyrank 删除表中指定位置区间的元素
$redis -& zremrangebyrank ( 'zset1' , 0 , 10 ) ;
//删除位置为0-10的元素,返回删除的元素个数2
hash表操作
//hset/hget 存取hash表的数据
$redis -& hset ( 'hash1' , 'key1' , 'v1' ) ;
//将key为'key1' value为'v1'的元素存入hash1表
$redis -& hset ( 'hash1' , 'key2' , 'v2' ) ;
$redis -& hget ( 'hash1' , 'key1' ) ;
//取出表'hash1'中的key 'key1'的值,返回'v1'
//hexists 返回hash表中的指定key是否存在
$redis -& hexists
( 'hash1' , 'key1' ) ;
//true or false
//hdel 删除hash表中指定key的元素
$redis -& hdel ( 'hash1' , 'key2' ) ;
//true or false
//hlen 返回hash表元素个数
$redis -& hlen ( 'hash1' ) ;
//hsetnx 增加一个元素,但不能重复
$redis -& hsetnx ( 'hash1' , 'key1' , 'v2' ) ;
$redis -& hsetnx ( 'hash1' , 'key2' , 'v2' ) ;
//hmset/hmget 存取多个元素到hash表
$redis -& hmset ( 'hash1' , array ( 'key3' =& 'v3' , 'key4' =& 'v4' ) ) ;
$redis -& hmget ( 'hash1' , array ( 'key3' , 'key4' ) ) ;
//返回相应的值 array('v3','v4')
//hincrby 对指定key进行累加
$redis -& hincrby ( 'hash1' , 'key5' , 3 ) ;
$redis -& hincrby ( 'hash1' , 'key5' , 10 ) ;
//hkeys 返回hash表中的所有key
$redis -& hkeys ( 'hash1' ) ;
//返回array('key1','key2','key3','key4','key5')
//hvals 返回hash表中的所有value
$redis -& hvals ( 'hash1' ) ;
//返回array('v1','v2','v3','v4',13)
//hgetall 返回整个hash表元素
$redis -& hgetall ( 'hash1' ) ;
//返回array('key1'=&'v1','key2'=&'v2','key3'=&'v3','key4'=&'v4','key5'=&13)
//sort 排序
$redis -& rpush ( 'tab' , 3 ) ;
$redis -& rpush ( 'tab' , 2 ) ;
$redis -& rpush ( 'tab' , 17 ) ;
$redis -& sort ( 'tab' ) ;
//返回array(2,3,17)
//使用参数,可组合使用 array('sort' =& 'desc','limit' =& array(1, 2))
$redis -& sort ( 'tab' , array ( 'sort'
'desc' ) ) ;
//降序排列,返回array(17,3,2)
$redis -& sort ( 'tab' , array ( 'limit'
array ( 1 ,
//返回顺序位置中1的元素2个(这里的2是指个数,而不是位置),返回array(3,17)
$redis -& sort ( 'tab' , array ( 'limit'
array ( 'alpha'
true ) ) ) ;
//按首字符排序返回array(17,2,3),因为17的首字符是'1'所以排首位置
$redis -& sort ( 'tab' , array ( 'limit'
array ( 'store'
'ordered' ) ) ) ;
//表示永久性排序,返回元素个数
$redis -& sort ( 'tab' , array ( 'limit'
array ( 'get'
'pre_*' ) ) ) ;
//使用了通配符'*'过滤元素,表示只返回以'pre_'开头的元素
redis管理操作
//select 指定要操作的数据库
$redis -& select ( 'mydb' ) ;
//指定为mydb,不存在则创建
//flushdb 清空当前库
$redis -& flushdb ( ) ;
//move 移动当库的元素到其它库
$redis -& set ( 'foo' ,
$redis -& move ( 'foo' ,
'mydb2' ) ;
//若'mydb2'库存在
//info 显示服务当状态信息
$redis -& info ( ) ;
//slaveof 配置从服务器
$redis -& slaveof ( '127.0.0.1' , 80 ) ;
//配置127.0.0.1端口80的服务器为从服务器
$redis -& slaveof ( ) ;
//清除从服务器
//同步保存服务器数据到磁盘
$redis -& save ( ) ;
//异步保存服务器数据到磁盘
$redis -& bgsave ( ) ;
$redis -& bgrewriteaof ( ) ;
//返回最后更新磁盘的时间
$redis -& lastsave ( ) ;
//set/get多个key-value
'usr:0001'
'First user' ,
'usr:0002'
'Second user' ,
'usr:0003'
'Third user'
$redis -& mset ( $mkv ) ;
//存储多个key对应的value
$redis -& mget ( array_keys ( $mkv ) ) ;
//获取多个key对应的value
print_r ( $retval ) ;
//批量操作
$redis -& pipeline ( function ( $pipe )
$pipe -& ping ( ) ;
$pipe -& flushdb ( ) ;
$pipe -& incrby ( 'counter' ,
//增量操作
$pipe -& incrby ( 'counter' ,
$pipe -& exists ( 'counter' ) ;
$pipe -& get ( 'counter' ) ;
$pipe -& mget ( 'does_not_exist' ,
'counter' ) ;
print_r ( $replies ) ;
//CAS,事务性操作
function zpop ( $client ,
$zsetKey )
// Initialize with support for CAS operations
$zsetKey ,
// Key that needs to be WATCHed to detect changes
// Number of retries on aborted transactions, after
// which the client bails out with an exception.
$client -& multiExec ( $options ,
function ( $tx )
( $zsetKey ,
& $element )
@ list ( $element )
$tx -& zrange ( $zsetKey ,
( isset ( $element ) )
$tx -& multi ( ) ;
// With CAS, MULTI *must* be explicitly invoked.
$tx -& zrem ( $zsetKey ,
$element ) ;
= zpop ( $redis ,
'zset' ) ;
isset ( $zpopped ) ?
&ZPOPed $zpopped&
&Nothing to ZPOP!& ,
//对存取的key加前缀,如: 'nrk:'
$redis -& getProfile ( ) -& setPreprocessor ( new KeyPrefixPreprocessor ( 'nrk:' ) ) ;
//分布式存储的一些方法
$multiple_servers
'127.0.0.1' ,
'database'
'127.0.0.1' ,
'database'
'second' ,
use Predis\Distribution\IDistributionS
class NaiveDistributionStrategy implements IDistributionStrategy
function __constructor ( )
$this -&_nodes
array ( ) ;
$this -&_nodesCount
function add ( $node ,
$this -&_nodes [ ]
$this -&_nodesCount ++;
function remove ( $node )
$this -&_nodes
array_filter ( $this -&_nodes ,
function ( $n )
use ( $node )
$this -&_nodesCount
count ( $this -&_nodes ) ;
function get ( $key )
$this -&_nodesC
new RuntimeException ( 'No connections' ) ;
$this -&_nodes [ $count
abs ( crc32 ( $key )
function generateKey ( $value )
crc32 ( $value ) ;
//配置键分布策略
'key_distribution'
new NaiveDistributionStrategy ( ) ,
new Predis\Client ( $multiple_servers ,
$options ) ;
$i set ( &key:$i& ,
str_pad ( $i ,
$redis -& get ( &key:$i& ) ;
$redis -& getClientFor ( 'first' ) -& info ( ) ;
$redis -& getClientFor ( 'second' ) -& info ( ) ;
printf ( &Server '%s' has %d keys while server '%s' has %d keys.\n& ,
$server1 [ 'db15' ] [ 'keys' ] ,
'second' ,
$server2 [ 'db15' ] [ 'keys' ]
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2629次
排名：千里之外
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'Redis是一种高级key-value数据库。它跟memcached类似，不过数据可以持久化，而且支持的数据类型很丰富。有字符串，链表、哈希、集合和有序集合5种。支持在服务器端计算集合的并、交和补集(difference)等，还支持多种排序功能。所以Redis也可以被看成是一个数据结构服务器。Redis的所有数据都是保存在内存中，然后不定期的通过异步方式保存到磁盘上(这称为&半持久化模式&)；也可以把每一次数据变化都写入到一个append only file(aof)里面(这称为&全持久化模式&)。
首先判断客户端和服务器连接是否正常
# 客户端和服务器连接正常，返回PONG
redis& PING
# 客户端和服务器连接不正常(网络不正常或服务器未能正常运行)，返回连接异常
redis 127.0.0.1:6379& PING
Could not connect to Redis at 127.0.0.1:6379: Connection refused
Redis 监控最直接的方法就是使用系统提供的 info 命令，只需要执行下面一条命令，就能获得 Redis 系统的状态报告。
redis-cli info
结果会返回 Server、Clients、Memory、Persistence、Stats、Replication、CPU、Keyspace 8个部分。从info大返回结果中提取相关信息，就可以达到有效监控的目的。
先解释下各个参数含义
redis_version:2.8.8
# Redis 的版本
redis_git_sha1:
redis_git_dirty:0
redis_build_id:bf5df
redis_mode:standalone
os:Linux 2.6.32-220.7.1.el6.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
gcc_version:4.4.7
process_id:49324
# 当前 Redis 服务器进程id
run_id:bbd7b17efcf108fdde285df6a38f48
tcp_port:6379
uptime_in_seconds:1739082
# 运行时间(秒)
uptime_in_days:20
# 运行时间(天)
lru_clock:1734729
config_file:/home/s/apps/RedisMulti_video_so/conf/zzz.conf
connected_clients:1
#连接的客户端数量
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0
used_memory:821848
#Redis分配的内存总量
used_memory_human:802.59K
used_memory_rss:
#Redis分配的内存总量(包括内存碎片)
used_memory_peak:
used_memory_peak_human:170.70M
#Redis所用内存的高峰值
used_memory_lua:33792
mem_fragmentation_ratio:104.07
#内存碎片比率
mem_allocator:tcmalloc-2.0
# Persistence
rdb_changes_since_last_save:0
#上次保存数据库之后，执行命令的次数
rdb_bgsave_in_progress:0
#后台进行中的 save 操作的数量
rdb_last_save_time:
#最后一次成功保存的时间点，以 UNIX 时间戳格式显示
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:0
rdb_current_bgsave_time_sec:-1
aof_enabled:0
#redis是否开启了aof
aof_rewrite_in_progress:0
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1
aof_current_rewrite_time_sec:-1
aof_last_bgrewrite_status:ok
aof_last_write_status:ok
total_connections_received:5705
#运行以来连接过的客户端的总数量
total_commands_processed:204013
# 运行以来执行过的命令的总数量
instantaneous_ops_per_sec:0
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:34401
#运行以来过期的 key 的数量
evicted_keys:0
#运行以来删除过的key的数量
keyspace_hits:2129
#命中key 的次数
keyspace_misses:3148
#没命中key 的次数
pubsub_channels:0
#当前使用中的频道数量
pubsub_patterns:0
#当前使用中的模式数量
latest_fork_usec:4391
# Replication
role:master
#当前实例的角色master还是slave
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
used_cpu_sys:1551.61
used_cpu_user:1083.37
used_cpu_sys_children:2.52
used_cpu_user_children:16.79
# Keyspace
db0:keys=3,expires=0,avg_ttl=0
#各个数据库的 key 的数量，以及带有生存期的 key 的数量
如果 Redis 使用的内存超出了可用的物理内存大小，那么 Redis 很可能系统会被杀掉。针对这一点，你可以通过 info 命令对 used_memory 和 used_memory_peak 进行监控，为使用内存量设定阀值，并设定相应的报警机制。当然，报警只是手段，重要的是你得预先计划好，当内存使用量过大后，你应该做些什么，是清除一些没用的冷数据，还是把 Redis 迁移到更强大的机器上去。
如果因为你的机器或 Redis 本身的问题导致 Redis 崩溃了，那么你唯一的救命稻草可能就是 dump 出来的rdb文件了，所以，对 Redis dump 文件进行监控也是很重要的。可以通过对rdb_last_save_time 进行监控，了解最近一次 dump 数据操作的时间，还可以通过对rdb_changes_since_last_save进行监控来获得如果这时候出现故障，会丢失（即已改变）多少数据。
通过获取Keyspace中的结果得到各个数据库中key的数量
即每分钟执行的命令个数，即：(total_commands_processed2-total_commands_processed1)/span，为了实时得到QPS，可以设定脚本在后台运行，记录过去几分钟的total_commands_processed。在计算QPS时，利用过去的信息和当前的信息得出QPS的估计值。
阅读(...) 评论()Redis是典型的NoSQL数据库( Not Only SQL)
　　NoSQL数据库:
　　　　NoSQL,泛指非关系型的数据库。随着互联网web2.0网站的兴起，
　　　　传统的关系数据库在应付web2.0网站，
　　　　特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，
　　　　暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。
　　　　NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，
　　　　尤其是大数据应用难题。 Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。 Redis 与其他 key - value 缓存产品有以下三个特点：
Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。
Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
Redis支持数据的备份，即master-slave模式的数据备份。 　　Redis 优势
　　　　性能极高 & Redis能读的速度是110000次/s,写的速度是81000次/s 。
　　　　丰富的数据类型 & Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
　　　　原子 & Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行。
　　　　丰富的特性 & Redis还支持 publish/subscribe, 通知, key 过期等等特性。 　　Redis与其他key-value存储有什么不同？
　　1.复杂的数据类型
　　2.可以持久化到磁盘,追加方式添加
安装Reids到本地:
下载地址：/MSOpenTech/redis/releases 打开Redis 客户端使用关键字 Ping 如果为PONG则表示安装成功
可以使用以下的命令设置密码
1.查看是否设置了密码 config get requirepass2.设置密码
config set requirepass "runoob"3.连接 auth "password"
阅读(...) 评论()2234人阅读
工具类（20）
Redis(Windows)安装与使用
转自:http://blog.csdn.net/enzoy/article/details/
Redis Windows 下安装
下载地址：
下载下来的包里有两个，一个是32位的，一个是64位的。
把这个文件夹复制到其它地方，比如D：\redis 目录下。
打开一个cmd窗口& 使用cd命令切换目录到d:\redis& 运行 redis-server.exe redis.conf&
如果想方便的话，可以把redis的路径加到系统的环境变量里，这样就省得再输路径了，后面的那个redis.conf可以省略，如果省略，会启用默认的。输入之后，会显示如下界面：
这时候别启一个cmd窗口，原来的不要关闭，不然就无法访问服务端了
切换到redis目录下运行 redis-cli.exe -h 127.0.0.1 -p 6379 出现下图
redis.conf配置文件相关说明
Redis Linux下安装
Redis的代码遵循ANSI-C编写，可以在所有POSIX系统（如Linux, *BSD, Mac OS X, Solaris等）上安装运行。而且Redis并不依赖任何非标准库，也没有编译参数必需添加。redis的安装出奇的简单，这可能也是他风靡的一个原因，让人很容易上手，不像某些东西，编译阶段就能让人完全绝望。
安装命令：
$ tar xzf redis-2.8.19.tar.gz
$ cd redis-2.8.19
需要说明的事，redis的安装非常简单，已经有现成的Makefile文件，直接运行make命令即可。
Redis 由四个可执行文件：redis-benchmark、redis-cli、redis-server、redis-stat 这四个文件，加上一个redis.conf就构成了整个redis的最终可用包。它们的作用如下：
redis-server：Redis服务器的daemon启动程序
redis-cli：Redis命令行操作工具。当然，你也可以用telnet根据其纯文本协议来操作
redis-benchmark：Redis性能测试工具，测试Redis在你的系统及你的配置下的读写性能
redis-stat：Redis状态检测工具，可以检测Redis当前状态参数及延迟状况
现在就可以启动redis了，redis只有一个启动参数，就是他的配置文件路径。
Run Redis with:
$ src/redis-server
You can interact with Redis using the built-in client:
$ src/redis-cli
redis& set foo bar
redis& get foo
注意，默认复制过去的redis.conf文件的daemonize参数为no，所以redis不会在后台运行，这时要测试，我们需要重新开一个终端。修改为yes则为后台运行redis。另外配置文件中规定了pid文件，log文件和数据文件的地址，如果有需要先修改，默认log信息定向到stdout.
下面是redis.conf的主要配置参数的意义：
daemonize：是否以后台daemon方式运行
pidfile：pid文件位置
port：监听的端口号
timeout：请求超时时间
loglevel：log信息级别
logfile：log文件位置
databases：开启数据库的数量
save * *：保存快照的频率，第一个*表示多长时间，第三个*表示执行多少次写操作。在一定时间内执行一定数量的写操作时，自动保存快照。可设置多个条件。
rdbcompression：是否使用压缩
dbfilename：数据快照文件名（只是文件名，不包括目录）
dir：数据快照的保存目录（这个是目录）
appendonly：是否开启appendonlylog，开启的话每次写操作会记一条log，这会提高数据抗风险能力，但影响效率。
appendfsync：appendonlylog如何同步到磁盘（三个选项，分别是每次写都强制调用fsync、每秒启用一次fsync、不调用fsync等待系统自己同步）
这时你可以打开一个终端进行测试了，配置文件中默认的监听端口是6379
我们可以开启一个Redis客户端进行测试
[root@SNDA-192-168-1-114 ~]# redis-cli
Could not connect to Redis at 127.0.0.1:6379: Connection refused
not connected& exit
[root@SNDA-192-168-1-114 ~]# redis-server /etc/redis.conf
[root@SNDA-192-168-1-114 ~]# redis-cli
redis 127.0.0.1:6379& quit
Linux 下安装遇到的问题
1.make test 时出现：
You need tcl 8.5 or newer in order to run the Redis test
make: *** [test] Error 1
解决参考： （在另一台服务器上安装，上面的方法还是不能安装.....）------这里准备在之前安装成功的机器上再建一个Slave测试吧，不知道另一台机器为什么无法安装，可能是权限的问题。
发现即使报了错，但是启动redis的时候确实没问题的，既然这样，就先用吧，这样就可以用两台机器做主从测试了~~~~，继续！！
Redis 常用命令
1. 手动抓取快照，save或者bgsave（后台异步）
redis& save
redis& bgsave
Background saving started
2. 获取某个key的类型
redis& type mylist
3. 匹配所有符合模式的key，*代表所有
redis& keys *
2) &mylist&
4. 随机返回一个key
redis& randomkey
5. 重命名一个key
redis& rename name myname
redis& keys *
1) &myname&
2) &mylist&
6. list的一些操作
6.1 将一个值添加到列表的首部
redis& rpush company taobao
(integer) 1
redis& lrange company 0 1
1)&&& &taobao&
6.2 将一个值添加到列表的尾部
redis& lpush company sina
(integer) 2
redis& lrange company 0 1
2) &taobao&
6.3 获得列表长度
redis& llen company
(integer) 2
6.4 返回list中某个范围的值，模式LRANGE key start end
redis& lrange company 1 2
1) &taobao&
6.5 只保留list中某个范围的值，模式LTRIM key start end
redis& lrange company 0 2
2) &taobao&
redis& ltrim company 0 1
redis& lrange company 0 2
2) &taobao&
6.6 获得list中某个索引号的值，模式LINDEX key index
redis& lrange company 0 4
1) &baidu&
4) &taobao&
redis& lindex company 2
redis& lindex company 0
6.7 设置list中某个索引位置的值，模式LSET key index value
redis& lrange company 0 4
1) &baidu&
4) &taobao&
redis& lset company 2 google
redis& lrange company 0 4
1) &baidu&
3) &google&
4) &taobao&
6.8 用lpop获取list中索引最小的值（头部值），rpop获取list中索引最大的值（尾部值），注意获取之后list中就不再有这个值了。
redis& lrange company 0 4
1) &baidu&
3) &google&
4) &taobao&
redis& lpop company
redis& rpop company
redis& lrange company 0 4
2) &google&
特别注意：以上这些命令中的start或者index都是从0开始计算的
7. 集合的一些操作
7.1 向集合中增加一个元素，模式SADD key member
redis& sadd class kongxing
(integer) 1
redis& type class
7.2 列出集合中的所有元素，注意元素是无序的，模式SMEMBERS key
redis& smembers class
1) &banqiao&
2) &rulong&
3) &changjie&
4) &kongxing&
7.3 从集合中删除一个元素，模式SREM key member
redis& srem class kongxing
(integer) 1
redis& smembers class
1) &banqiao&
2) &rulong&
3) &changjie&
7.4 返回集合大小，模式SCARD key
redis& scard class
(integer) 3
7.5 判断某个值是否在集合中，模式SISMEMBER key member
redis& sismember class kongxing
(integer) 0—表示没有’kongxing’这个元素
redis& sismember class rulong
(integer) 1—表示存在’rulong’这个元素
7.6 获取多个集合的交集元素，模式SINTER key1 key2 ... keyN
redis& smembers dba
1) &rulong&
2) &changjie&
redis& smembers class
1) &banqiao&
2) &rulong&
3) &kongxing&
4) &changjie&
redis& sinter class dba
1) &rulong&
2) &changjie&
redis& sinter dba class
1) &rulong&
2) &changjie&
---注意：取交集，所以与各个key的位置无关&
8.其他命令
8.1 启动 Redis 服务
src/redis-server或者src/redis-server redis.conf
src/redis-server redis.conf 1&log.log 2&errlog.log
1为标准输出，2为错误输出
8.2 将 Redis 作为 Linux 服务随机启动
vi /etc/rc.local, 加入代码：
/root/install/redis-2.4.9/src/redis-server
8.3 客户端连接
src/redis-cli
8.4 停止redis服务：
src/redis-cli shutdown
8.5 当前的key是否存在
exists larry
(integer) 0
8.6 删除当前key
8.7设置过期时间
expire larry 10
(integer) 1
8.8移动larry键值对到ad4数据库
move larry ad4
(integer) 1
8.9移除当前key的过期时间
persist lv
(integer) 1
8.10 测试连接是否还在
8.11数据库切换
select ad4databank
8.12退出连接
8.13当前数据库中key的数量
(integer) 12
8.14服务器基本信息
8.15实时转储收到的请求
8.16获取服务器的参数配置
config get
8.17清空当前数据库
8.18清除所有数据库
Redis 性能
下面是官方的bench-mark数据：
The test was done with 50 simultaneous clients performing 100000 requests.
The value SET and GET is a 256 bytes string.
The Linux box is running Linux 2.6, it’s Xeon XGhz.
Text executed using the loopback interface (127.0.0.1).
Results: about 110000 SETs per second, about 81000 GETs per second.
更多详细数据请见官方bench-mark page（）
redis安装使用
转自:http://blog.csdn.net/zhang_yanan/article/details/
redis是一个高性能的key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。
Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。从盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。
2 文档目的
供运维人员了解学习简单的redis操作，个人如果想要深入了解redis，可自行深入学习了解。
3 状态及类型
下载redis安装包redis-2.8.8.tar.gz
3.1 编译安装
cd /usr/local/src/
tar zxvf redis-2.8.8.tar.gz
cd redis-2.8.8
make PREFIX=/home/rediscmcc install
在安装redis成功后，你将可以在/home/rediscmcc看到一个bin的目录，里面包括了以下文件：
&redis-benchmark& redis-check-aof& redis-check-dump& redis-cli& redis-server
文件解释：
redis-benchmark
&Redis性能测试工具，测试redis在你的系统及配置下的读写性能
redis-check-aof
&更新日志检查
redis-check-dump
&检查本地数据库文件
&Redis命令行操作工具。也可以用telnet根据其纯文本协议来操作
redis-server
&Redis服务器的daemon启动程序
3.2 设置配置文件参数
创建接下来要使用的目录：
Cd /home/rediscmcc
mkdir data
mkdir logdir
mkdir config
cp redis.conf /home/rediscmcc/config/& Copy一份配置文件
cd /home/rediscmcc/config/
vi redis.conf& 设置配置文件中参数
修改一下配置
daemonize yes
pidfile /home/rediscmcc/data/redis.pid
logfile &/home/rediscmcc/logdir/redis.log&
dbfilename dump.rdb
dir /home/rediscmcc/data
# maxmemory &bytes&
# maxmemory-policy volatile-lru
注：配置文件中名词解释见下文附件。
3.3 简单运行redis
./redis-server /home/rediscmcc/config/redis.conf
3.4 查看redis服务是否启动成功，端口6379
netstat -tlunp
3.5 测试使用redis
Redis客户端指定端口进入redis
./redis-cli -p 6379
可以使用set ，get，quit等简单命令测试是否可以正常使用
关闭redis：
Redis-cli shutdown
关闭指定端口的redis-server
Redis-lic -p 6379 shutdown
4 将redis做成一个服务
注：此处可做可不做。当两个redis数据库在同一台服务器上运行时，容易造成混淆现象。
4.0.1 复制脚本到/etc/rc.d/init.d目录
按以上步骤安装Redis时，其服务脚本位于：
/usr/local/src/redis-2.8.8/utils/redis_init_script
必须将其复制到/etc/rc.d/init.d的目录下：
cp /usr/local/src/redis/utils/redis_init_script /etc/rc.d/init.d/redis
以下将redis_init_script复制到/etc/rc.d/init.d/，同时易名为redis。
如果这时，我们直接注册服务：
chkconfig --add redis
将报以下错误：
引用redis服务不支持chkconfig，为此我们需要更改redis的脚本。
4.0.2 更改redis的服务脚本
#vim /etc/rc.d/init.d/redis
看到以下的文件内容：
#!/bin/bash
#chkconfig:&
# description:& Redis is a persistent key-value database
# Simple Redis init.d script conceived to work on Linux systems
# as it does use of the /proc filesystem.
REDISPORT=6379
EXEC=/home/rediscmcc/bin/redis-server
CLIEXEC=/home/rediscmcc/bin/redis-cli
PIDFILE=/home/rediscmcc/data/redis_${REDISPORT}.pid
CONF=&/home/rediscmcc/config/${REDISPORT}.conf&
case &$1& in
&&& start)
&&&&&&& if [ -f $PIDFILE ]
&&&&&&& then
&&&&&&&&&&&&&&& echo &$PIDFILE exists, process is already running or crashed&
&&&&&&& else
&&&&&&&&&&&&&&& echo &Starting Redis server...&
&&&&&&&&&&&&&&& $EXEC $CONF &
&&&&&&& fi
&&&&&&& ;;
&&&&&&& if [ ! -f $PIDFILE ]
&&&&&&& then
&&&&&&&&&&&&&&& echo &$PIDFILE does not exist, process is not running&
&&&&&&& else
&&&&&&&&&&&&&&& PID=$(cat $PIDFILE)
&&&&&&&&&&&&&&& echo &Stopping ...&
&&&&&&&&&&&&&&& $CLIEXEC -p $REDISPORT shutdown
&&&&&&&&&&&&&&& while [ -x /proc/${PID} ]
&&&&&&&&&&&&&&& do
&&&&&&&&&&&&&&&&&&& echo &Waiting for Redis to shutdown ...&
&&&&&&&&&&&&&&&&&&& sleep 1
&&&&&&&&&&&&&&& done
&&&&&&&&&&&&&&& echo &Redis stopped&
&&&&&&& fi
&&&&&&& ;;
&&&&&&& echo &Please use start or stop as first argument&
&&&&&&& ;;
chkconfig --add redis
chkconfig --list redis 查看
redis&&&&&&&&&& 0:off&& 1:off&& 2:on&&& 3:on&&& 4:on&&& 5:on&&& 6:off
以上redis文件中所修改地方的解释：
#chkconfig:&
添加注册redis，冒号后边有空格
# description:& Redis is a persistent key-value database
上边的这行信息必须添加，不添加执行不成功，原因暂时不知道。
设置EXEC、CLIEXEC、PIDFILE、CONF参数对应的路径，一定要和前边安装时设定的路径保持一致。
&$EXEC $CONF & 后台运行
4.1 服务启动方式启动redis
[root@localhost init.d]# service redis start
Starting Redis server...
[4223] 08 May 17:30:04.706 # Fatal error, can't open config file '/home/rediscmcc/config/6379.conf'
启动过程中找不到6379.conf文件
解决方法：
Copy redis配置文件到config目录下
先备份config下的redis.conf文件
Cp /home/rediscmcc/config/redis.conf /home/rediscmcc/config/redis.conf.bak
Mv /home/rediscmcc/config/redis.conf /home/rediscmcc/config/6379.conf
修改6379.conf配置文件中信息，保持和/etc/re.d/init.d/redis中文件设置保持一致
只需要修改以下配置
pidfile /home/rediscmcc/data/redis_6379.pid
启动redis程序
# service redis start
Starting Redis server...
[root@localhost src]# service redis stop
Stopping ...
Redis stopped
5 Redis主从复制
5.1 原理：
Reids的主从复制功能很强大，一个master可以拥有多个slave，而一个slave又可以拥有多个slave，如此下去，形成了强大的多级服务器集群架构。
5.2 Redis主从复制的特点
1.master可以有多个slave
2.除了多个slave连到相同的master外，slave也可以连接其他slave形成图状结构
3.主从复制不会阻塞master。也就是说当一个或多个slave与master进行初次同步数据时，master可以继续处理client发来的请求。相反slave在初次同步数据时则会阻塞不能处理client的请求。
4.主从复制可以用来提高系统的可伸缩性,我们可以用多个slave 专门用于client的读请求，比如sort操作可以使用slave来处理。也可以用来做简单的数据冗余
5.可以在master禁用数据持久化，只需要注释掉master 配置文件中的所有save配置，然后只在slave上配置数据持久化。
5.3 redis主从复制过程
当设置好slave服务器后，slave会建立和master的连接，然后发送sync命令。无论是第一次同步建立的连接还是连接断开后的重新连 接，master都会启动一个后台进程，将数据库快照保存到文件中，同时master主进程会开始收集新的写命令并缓存起来。后台进程完成写文件 后，master就发送文件给slave，slave将文件保存到磁盘上，然后加载到内存恢复数据库快照到slave上。接着master就会把缓存的命 令转发给slave。而且后续master收到的写命令都会通过开始建立的连接发送给slave。从master到slave的同步数据的命令和从
client发送的命令使用相同的协议格式。当master和slave的连接断开时slave可以自动重新建立连接。如果master同时收到多个 slave发来的同步连接命令，只会使用启动一个进程来写数据库镜像，然后发送给所有slave。
5.4 Redis主从复制配置
5.5 主从配置方式
主：10.15.62.115& 端口：6379&& 目录名：redisma
从：10.15.62.115 端口：16379& 目录名：redissa
l 主从配置区别如下：
& pidfile /home/redisma/data/redis.pid
& pidfile /home/redissa/data/redis.pid
& port 6379
& port 16379
& logfile &/home/redisma/logdir/6379.log&
& logfile &/home/redissa/logdir/16379.log&
& dir /home/redisma/data
& dir /home/redissa/data
& # slaveof &masterip& &masterport&
& slaveof 10.15.62.238 6379
l 分别启动主从redis，测试数据同步
[root@localhost redisma]# bin/redis-cli -p 6379
&&&&& 127.0.0.1:6379& set name abc
&&&&& 127.0.0.1:6379& get name
&&&&& &abc&
&&&&& 127.0.0.1:6379&
&&&&& [root@localhost redissa]# bin/redis-cli -p 16379
&&&&& 127.0.0.1:16379& get name
&&&&& &abc&
&&&&& 127.0.0.1:16379&
l 默认是读写分离的
在从redis：
&&&& [root@localhost redisma]# bin/redis-cli -p 16379
&&&& 127.0.0.1:16379& set name 123
&&&& (error) READONLY You can't write against a read only slave.
5.6 主从切换
l 模拟主redis停止工作，切换到从redis（从redis默认为只读）
停止主redis
[root@localhost redisma]# bin/redis-cli -n 6379 shutdown
[root@localhost redisma]# bin/redis-cli -p 6379
Could not connect to Redis at 127.0.0.1:6379: Connection refused
not connected&
将从redis设成主redis
[root@localhost redissa]# bin/redis-cli -p 16379 slaveof NO ONE
测试从redis是否切换从主redis
[root@localhost redissa]# bin/redis-cli -p 16379
127.0.0.1:16379& set name 123
127.0.0.1:16379& get name
127.0.0.1:16379&
l 原来的主redis恢复正常了，要重新切换回去
1) 将现在的主redis的数据进行保存
[root@localhost redissa]# bin/redis-cli -p 16379
127.0.0.1:6380& get name
127.0.0.1:6380& set name 123
127.0.0.1:6380& get name
127.0.0.1:6380& save
127.0.0.1:6380& get name
127.0.0.1:6380&&
2) 将现在的主redis根目录下dump.rdb文件拷贝覆盖到原来主redis的根目录
3) 启动原来的主redis
4) 在现在的主redis中切换
[root@localhost redisssa]# bin/redis-cli -p 16379 slaveof 10.15.62.238 6379
6 附件（配置文件名词解释）
1、默认不是以守护进程的方式运行，修改此配置项，使用yes是以后台daemon方式运行
daemonize yes redis
2、当redis以守护进程运行时，默认会生产pid文件，指定pidfile文件路径；
pidfile /home/rediscmcc/data/redis.pid
3、redis监听端口；
4、指定log日志文件和数据库文件存放目录路径
logfile &/home/rediscmcc/logdir/redis.log&
指定数据库文件存放目录；
dir /home/rediscmcc/data
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 &dbid&命令在连接上指定数据库id
databases 16
9. 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
save &seconds& &changes&
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. 指定本地数据库存放目录
13. 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步
slaveof &masterip& &masterport&
14. 当master服务设置了密码保护时，slav服务连接master的密码
masterauth &master-password&
15. 设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH &password&命令提供密码，默认关闭
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 &bytes&
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的内存。
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
Redis常用命令
转自:http://blog.csdn.net/ithomer/article/details/9213185
Redis常用命令集
1）连接操作命令
quit：关闭连接（connection）
auth：简单密码认证
help cmd： 查看cmd帮助，例如：help quit
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
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的子串
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的头部
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的一个元素
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高级应用
&&& 设置客户端连接后进行任何操作指定前需要密码，一个外部用户可以再一秒钟进行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
set age 10
set age 20
get age --这个内容就应该是20
set age 20
set age 10
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 &hostname&&&& Server hostname (default: 127.0.0.1)
& -p &port&&&&&&&& Server port (default: 6379)
& -s &socket&&&&&& Server socket (overrides hostname and port)
& -a &password&&&& Password to use when connecting to the server
& -r &repeat&&&&&& Execute specified command N times
& -i &interval&&&& When -r is used, waits &interval& seconds per command.
&&&&&&&&&&&&&&&&&& It is possible to specify sub-second times like -i 0.1
& -n &db&&&&&&&&&& Database number
& -x&&&&&&&&&&&&&& Read last argument from STDIN
& -d &delimiter&&& 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 &file&&&& Send an EVAL command using the Lua script at &file&
& --help&&&&&&&&&& Output this help and exit
& --version&&&&&&& Output version and exit
& 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
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：279214次
积分：3678
积分：3678
排名：第9346名
原创：45篇
转载：107篇
评论：25条
(1)(1)(1)(2)(1)(2)(2)(2)(1)(9)(1)(1)(6)(3)(2)(4)(1)(5)(3)(1)(3)(1)(1)(1)(2)(2)(2)(3)(1)(6)(16)(11)(4)(3)(3)(2)(1)(1)(4)(4)(6)(10)(5)(3)(5)(1)(2)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'