分类目录归档:NoSQL

TokeyTyrant (TT Server) ULog 管理,数据清空以及结构优化[转]

TT Server 做为比较方便的KV系统,他提供了Memcache协议进行数据操作,但是没有提供API来作为对其的一个管理机制,他只提供了Shell的方式管理,并且文档相对来说比较少,所以我自己写了一个TTServer的 Ulog 清理和数据库自动清空的脚本来做自动管理,希望有类似需求的同学可以从这个我这个脚本中裁剪出自己需要的脚本,自动运行可以采取Crontab来完成。

[shell]
#!/bin/bash
#请正确设置下面的三个关键变量,目录的话不要用/结尾
TT_INSTALL_HOME="/usr/local/bin" #TTServer 安装文件目录
DIR_ULOG="/home/remon/DevelopKit/server/TT/tokyotyrant/tokyotyrant-1.1.41/ulog" #ulog所在目录
TT_SERVICE_PORT="8080"
#以上三个变量请务必设置正确
if [ -z $1 -a -d $DIR_ULOG ]
then
echo "Please input ulog dir"
exit
fi
cd $DIR_ULOG
ULOG_FILE_COUNT=`find $DIR_ULOG -name ‘*.ulog’ | wc -l` #获取ULOG文件数量
JUMP_FILE_COUNT=0 #ULOG文件不删除文件计数
STR_CURTIME=`date +"%Y-%m-%d %H:%M:%S"` #当前的系统时间
DATA_CURTIME=`date -d "$STR_CURTIME" +%s` #转换成秒
PROCESS_RES_FILE="$DIR_ULOG/res.txt" #处理日志输出文件
echo "ulog dir : " $DIR_ULOG
echo System time is $STR_CURTIME
echo "Ulog file count : " $ULOG_FILE_COUNT
echo "******** Start empty tt’s data! ********" >> $PROCESS_RES_FILE
$TT_INSTALL_HOME/tcrmgr vanish -port $TT_SERVICE_PORT localhost
$TT_INSTALL_HOME/tcrmgr optimize -port $TT_SERVICE_PORT localhost
echo "******** TT is cleared up! ********" >> $PROCESS_RES_FILE
echo "******** Start clear ulog file! ********" >> $PROCESS_RES_FILE
DELAY_TIME=$($TT_INSTALL_HOME/tcrmgr inform -port $TT_SERVICE_PORT -st localhost | awk ‘$1=="delay"”{print $2}’)
if [ -z $DELAY_TIME ]
then
DELAY_TIME=60 #如果无法查询得到复制延迟,那么设定延迟时间为60秒
fi
DELAY_TIME=$(printf %.0f $DELAY_TIME) #将时差四舍五入为整数
for ULOG_FILE in `ls -t $DIR_ULOG | awk ‘{print $1}’`
do
FILE_SUFFIX=${ULOG_FILE##*.} #获取文件后缀名
STR_LASTTIME=$(ls -lt $ULOG_FILE | awk ‘{print $6,$7}’) #获取文件的最后时间
DATA_LASTTIME=`date -d "$STR_LASTTIME" +%s` #转换成秒
INTERVAL_TIME=`expr $DATA_CURTIME – $DATA_LASTTIME` #计算2个时间的差
if [ $INTERVAL_TIME -gt $DELAY_TIME -a $FILE_SUFFIX = "ulog" ]
then
if [ $JUMP_FILE_COUNT -lt 2 ] #最后保留两个最新的ULOG文件,即使这个ULOG最后修改时间和当前时间的差大于同步时差。
then
((JUMP_FILE_COUNT=$JUMP_FILE_COUNT + 1))
continue
fi
echo file will be deleted: $ULOG_FILE $INTERVAL_TIME S >> $DIR_ULOG/res.txt
#rm -rf $ULOG_FILE
fi
done
echo "******** ULog file cleared up! ********" >> $PROCESS_RES_FILE
echo -e "Task over!" `date` "/n/n" >> $PROCESS_RES_FILE
[/shell]

转自:http://blog.csdn.net/DAGiGi/article/details/6265083

Redis常用命令

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

连接操作相关的命令

Ÿ   quit:关闭连接(connection)

Ÿ   auth:简单密码认证

对value操作的命令

Ÿ   exists(key):确认一个key是否存在

Ÿ   del(key):删除一个key

Ÿ   type(key):返回值的类型

Ÿ   keys(pattern):返回满足给定pattern的所有key

Ÿ   randomkey:随机返回key空间的一个key

Ÿ   rename(oldnamenewname):将key由oldname重命名为newname,若newname存在则删除newname表示的key

Ÿ   dbsize:返回当前数据库中key的数目

Ÿ   expire:设定一个key的活动时间(s)

Ÿ   ttl:获得一个key的活动时间

Ÿ   select(index):按索引查询

Ÿ   move(keydbindex):将当前数据库中的key转移到有dbindex索引的数据库

Ÿ   flushdb:删除当前选择数据库中的所有key

Ÿ   flushall:删除所有数据库中的所有key

对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(keytimevalue):向库中添加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的子串

对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秒,如果问题没有解决,则对key i+1开始的list执行pop操作。

Ÿ   brpop(key1, key2,… key N, timeout):rpop的block版本。参考上一命令。

Ÿ   rpoplpush(srckey, dstkey):返回并删除名称为srckey的list的尾元素,并将该元素添加到名称为dstkey的list的头部

对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的一个元素

对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(dstkeyNkey1,…,keyN, WEIGHTS w1,…wN, AGGREGATE SUM|MIN|MAX):对N个zset求并集和交集,并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score,在进行AGGREGATE运算前,都要乘以对于的WEIGHT参数。如果没有提供WEIGHT,默认为1。默认的AGGREGATE是SUM,即结果集合中元素的score是所有集合对应元素进行SUM运算的值,而MIN和MAX是指,结果集合中元素的score是所有集合对应元素中最小值和最大值。

对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

持久化

Ÿ   save:将数据同步保存到磁盘

Ÿ   bgsave:将数据异步保存到磁盘

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

Ÿ   shundown:将数据同步保存到磁盘,然后关闭服务

远程服务控制

Ÿ   info:提供服务器的信息和统计

Ÿ   monitor:实时转储收到的请求

Ÿ   slaveof:改变复制策略设置

Ÿ   config:在运行时配置Redis服务器

MySQL与NoSQL——SQL与NoSQL的融合[转]

写这一篇内容的原因是MySQL5.6.2突然推出了memcached的功能。NoSQL to InnoDB with Memcached的出现,可以看出NoSQL对关系数据库的确产生了巨大的影响,个人觉得这是一个非常大的进步,可以让开发人员更加方便的使用NoSQL和关系数据库。NoSQL一般被认为性能高于关系数据库,那么直接在InnoDB之上提供NoSQL功能并和MySQL共存是否是一个更好的选择呢?

MySQL with HandlerSocket

去年在twitter上看到HandlerSocket的出现,并宣称性能是Memcached的两倍时,非常令人吃惊,居然可以达到750000qps。接着HandlerSocket成为NoSQL领域谈论的焦点之一, 大量的人开始想要尝试,并做过一些自己的性能测试。 下图是HandlerSocket的结构图:

图1 HandlerSocket结构图(来源于官方)

HandlerSocket的出现,给我们眼前一亮的感觉。原来InnoDB的性能已经足够好,并可以直接提供NoSQL的功能。最大的好处就是可以共享MySQL的功能,DBA以前的经验一样可以用。但是有些小小的风险:

  • HandlerSocket没有与MySQL一起发布版本,因此对于使用MyISAM引擎的用户是无缘的。不过现在Percona-Server已经集成了HandlerSocket,可以非常方便的使用。
  • 目前大规模的成功案例并不多,国内也只有少部分公司在尝试,我知道的有飞信开放平台,据说还不错。
  • 官方给出的测试数据在应用场景上其实并不充分,至少测试的场景跟我们实际使用的场景相差很大。但是毫无疑问, HandlerSocket的性能比直接使用MySQL肯定要高效得多。

InnoDB with Memcached

也许是因为HandlerSocket的火爆的冲击,也许是受HandlerSocket的启发,MySQL开始关注NoSQL领域的应用,并在MySQL5.6.2版本增加了通过Memcached协议直接访问原生Innodb API的功能。

InnoDB with Memcached是在提供MySQL服务的同一进程中提供Memcached服务 ,这与HandlerSocket的架构模式几乎是一样的。虽然目前InnoDB with Memcached还是预览版本,但是我个人更看好它,因为:

  • 它使用Memcached协议,并同时支持文本和二进制协议,在client的选择和成熟度上就要胜出许多;
  • 其支持的三种cache模式,不但可以省去开发中使用Memcached来缓存数据的麻烦,并且具有更好的可靠性和数据一致性;
  • 在应用程序中,可以使用高效的memcached协议来操作数据,同时也可以使用sql进行复杂的查询操作;

注意:目前通过memcached的更新操作不会记录到binlog中,未来的版本会支持。

图二 InnoDB with Memcached

Memcached and MySQL Cluster

显而易见,我们会想到MySQL Cluster结合Memcached是一个更好的组合,MySQL Cluster提供了99.999%高可用性,并真正提供了去中心化的无缝高可扩展性。还有什么比这更人兴奋的呢。

MySQL已经提供了这样的功能,源代码在这里。这里有一个O’Reilly MySql Conference大会的PPT演示 ,你也可以看下这个功能开发者的一篇博客

图三 NDB with Memcached

MySQL Cluster虽然具有高可靠性和无缝扩展的优势,但是对于复杂SQL查询的效率却不能令人满意。不过对于仅仅依赖于key-value查询和写入的海量数据存储需求,MySQL Cluster with Memcached应该是个很好的选择。

总结

Memcached协议由于其简单、协议轻量、存在大量的client,所以提供兼容Memcached协议的产品比较占据先天的优势。

MySQL提供NoSQL的功能,个人觉得并不是MySQL耐不住寂寞,而是的确在响应用户的需求。我前面的文章也说过,“NoSQL只是一个概念,并不是一个数据库 产品,MySQL也可以是NoSQL”,现在也正应了这句话。NoSQL从架构上就约束了开发者的架构和开发方式,从而提高扩展性和性能,而NoSQL和MySQL的融合,也同时提供了复杂查询功能。

虽然MySQL提供了NoSQL功能,如果你要尝试的话,你的数据库设计必须从NoSQL从发,然后再考虑SQL查询功能。

SQL与NoSQL的融合的确会给开发者带来方便,比如最近很流行的Mongodb,它吸引开发最大的点就是支持简单的关系查询。SQL与NoSQL的融合可能是未来很多数据库产品的一个趋势。但是纯NoSQL数据库的优势也是显著的,就是他的简单、高效、易扩展。

参考链接:

关于作者

孙立,目前为去哪儿网(qunar.com)高级系统架构师。曾就职于凤凰网、ku6和搜狐。多年互联网从业经验和程序开发,对分布式搜索引擎的开发,高并发,大数据量网站系统架构优化,高可用性,可伸缩性,分布式系统缓存,数据库分表分库(sharding)等有丰富的经验,并且对运维监控和自动化运维控制有经验。是开源项目phplock,phpbuffer的作者。近期开发了一个NOSQL数据库存储INetDB,是NoSQL数据库爱好者。

本文已经首发于InfoQ中文站,版权所有,原文为《MySQL与NoSQL——SQL与NoSQL的融合》,如需转载,请务必附带本声明,谢谢。

InfoQ中文站是一个面向中高端技术人员的在线独立社区,为Java、.NET、Ruby、SOA、敏捷、架构等领域提供及时而有深度的资讯、高端技术大会如QCon 、线下技术交流活动QClub、免费迷你书下载如《架构师》等。​

tokyo tyrant 安装日志

tokyo tyrant是一个可持久化的缓存服务器,类似memcachedb,tokyo tyrant本身是个缓存服务器,但需要tokyo cabinet作为存储引擎,
就像memcachedb中的memcache需要berkeley db一样

1)安装存储引擎tokyo cabinet
[bash]
wget http://1978th.net/tokyocabinet/tokyocabinet-1.4.47.tar.gz
tar xzvf tokyocabinet-1.4.47.tar.gz
cd tokyocabinet-1.4.47
./configure –prefix=/path/to/tokyocabinet-1.4.47
make
sudo make install
[/bash]

2)如果需要使用像队列等扩展,则要安装lua
[bash]
wget http://www.lua.org/ftp/lua-5.1.4.tar.gz
tar zxf lua-5.1.4.tar.gz
cd lua-5.1.4
make linux
make install
[/bash]
如果出现类似如下错误:
In file included from lua.h:16,
from lua.c:15:
luaconf.h:275:31: error: readline/readline.h: No such file or directory
luaconf.h:276:30: error: readline/history.h: No such file or directory
lua.c: In function ‘pushline’:
lua.c:182: warning: implicit declaration of function ‘readline’
lua.c:182: warning: assignment makes pointer from integer without a cast
lua.c: In function ‘loadline’:
lua.c:210: warning: implicit declaration of function ‘add_history’
make[2]: *** [lua.o] Error 1
make[2]: Leaving directory `/root/tool/lua-5.1.4/src’
make[1]: *** [linux] Error 2
make[1]: Leaving directory `/root/tool/lua-5.1.4/src’
make: *** [linux] Error 2

则表示readline-devel没装, 执行yum -y install readline-devel安装,或者从源码安装:
[bash]
wget ftp://ftp.cwru.edu/pub/bash/readline-6.1.tar.gz
tar -zxvf readline-6.1.tar.gz
cd ~~ ./configure && make && make install
ldconfig
[/bash]

3)安装toyko tyrant
[bash]
wget http://1978th.net/tokyotyrant/tokyotyrant-1.1.41.tar.gz
tar xzvf tokyotyrant-1.1.41.tar.gz
cd tokyotyrant-1.1.41
./configure –prefix=/usr/local/tokyotyrant-1.1.41 –with-tc=/usr/local/tokyocabinet-1.4.47 –enable-lua
[/bash]

4) 测试
4.1)演示非持久性
4.1.1)启动服务:
bin/ttserver

4.1.2)使用客户端
另起一个终端
存放: bin/tcrmgr put localhost one first
获取: bin/tcrmgr get localhost one
得到结果 first

4.2.3)测试持久
重启ttserver,再次获取bin/tcrmgr get localhost one
没有结果

4.2)演示持久性
3.2.1)启动服务
bin/ttserver /tmp/x.tch

4.2.2)使用客户端
另起一个终端
存放: bin/tcrmgr put localhost one first
获取: bin/tcrmgr get localhost one

4.2.3)测试持久
重启ttserver
再次获取:
bin/tcrmgr get localhost one

Tokyo Tyrant(ttserver) java api的安装【转】

Tokyo Tyrant(ttserver)的安装请看我的上一篇文章http://gqf2008.iteye.com/admin/blogs/366963

 

 

编译java api

http://tokyocabinet.sourceforge.net/javapkg/tokyocabinet-java-1.18.tar.gz

tar zxvf tokyocabinet-java-1.18.tar.gz

cd tokyocabinet-java-1.18

编译时一定要设置JAVA_HOME环境变量,不然会报找不到jni.h错误

export JAVA_HOME=…..

./configure

make

make install

编辑当前用户的环境变量,增加一下这些参数

CLASSPATH=$CLASSPATH:/usr/local/lib/tokyocabinet.jar

LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib

export CLASSPATH LD_LIBRARY_PATH

重新登陆让环境变量生效,或者执行source ~/.bashrc (ubuntu下是这个文件)

 

跑一下例子

cd example

javac *.java

java TCBDBEX

hop

bar:step

baz:jump

foo:hop

 

java TCFDBEX

one

1:one

12:twelve

144:one forty four

 

java TCHDBEX

hop

foo:hop

bar:step

baz:jump

转自:http://gqf2008.iteye.com/blog/372753

tokyotyrant-java客户端[转]

目录:

概述
演示
[一]、概述

java实现了对ttserver服务端的连接和访问。相关的源代码和jar包可以到其官网下载。

官网地址:http://code.google.com/p/tokyotyrant-java/

如果是maven构建项目的,在pom.xml 的节点中增加如下依赖配置即可:
[xml]
<dependency>
<groupId>tokyotyrant</groupId>
<artifactId>tokyotyrant</artifactId>
<version>0.11</version>
</dependency>
<dependency>
<groupId>org.jboss.netty</groupId>
<artifactId>netty</artifactId>
<version>3.1.5.GA</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.5.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.5.6</version>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
[/xml]
[二]、演示

1.RDB :官方Tokyo Tyrant API的实现

演示代码:RDBExample.java

[java]
package com.micmiu.nosql.ttserver;

import java.io.IOException;
import java.net.InetSocketAddress;

import tokyotyrant.RDB;
import tokyotyrant.transcoder.DoubleTranscoder;
import tokyotyrant.transcoder.IntegerTranscoder;

/**
*
* blog http://www.micmiu.com
*
* @author Michael
*
*/
public class RDBExample {

public static void main(String[] args) throws IOException {

RDB db = new RDB();
try {
// connect to the server
// db.open(new NodeAddress("tcp://192.168.126.134:1978"));
db.open(new InetSocketAddress("192.168.126.134", 1978));

Object key;
Object value;
// store records
if (db.put("my_firstname", "Sun")) {
System.out.println("db put my_firstname successful.");
} else {
System.out.println("db put my_firstname error.");
}

if (db.put("my_lastname", "Michael")) {
System.out.println("db put my_lastname successful.");
} else {
System.out.println("db put my_lastname error.");
}

if (db.put("my_blogurl", "www.micmiu.com")) {
System.out.println("db put my_blogurl successful.");
} else {
System.out.println("db put my_blogurl error.");
}

if (db.put("my_weibo", "www.sina.com/ctosun")) {
System.out.println("db put my_weibo successful.");
} else {
System.out.println("db put my_weibo error.");
}

// retrieve records
value = db.get("my_blogurl");
System.out.println("test_blogurl =: " + value);

value = db.get("test_noexit");
System.out.println("test_noexit =: " + value);

System.out.println("===== test repeat put ");
db.put("test_desc", "hello world");
System.out.println("test_desc =: " + db.get("test_desc"));
db.put("test_desc", "repeat put value is hello Michael");
System.out.println("test_desc =: " + db.get("test_desc"));

// Initialize the iterator
System.out.println("===== access all key ");
db.iterinit();
while ((key = db.iternext()) != null) {
value = db.get(key);
System.out.println(key + " =: " + value);
}
System.out.println("===== test int double ");
// add int
db.put("int_i", 3, new IntegerTranscoder());
int i = db.addint("int_i", 4);
System.out.println(" i =: " + i);
System.out.println("int_i =: "
+ db.get("int_i", new IntegerTranscoder()));

// add double
db.put("dou_d", 3.0D, new DoubleTranscoder());
double d = db.adddouble("dou_d", 4.0D);
System.out.println(" d =: " + d);
System.out.println("dou_d =: "
+ db.get("dou_d", new DoubleTranscoder()));

} catch (Exception e) {
e.printStackTrace();
} finally {
// close the connection
db.close();
}
}
}
[/java]
运行日志如下:

db put my_firstname successful.
db put my_lastname successful.
db put my_blogurl successful.
db put my_weibo successful.
test_blogurl =: www.micmiu.com
test_noexit =: null
===== test repeat put
test_desc =: hello world
test_desc =: repeat put value is hello Michael
===== access all key
my_firstname =: Sun
my_lastname =: Michael
my_blogurl =: www.micmiu.com
my_weibo =: www.sina.com/ctosun
test_desc =: repeat put value is hello Michael
===== test int double
i =: 7
int_i =: 7
d =: 7.0
dou_d =: 7.0

2.MRDB :用于多数据源,可复制、可靠性高、响应快等特点

演示代码:MRDBExample.java

[java]
package com.micmiu.nosql.ttserver;

import tokyotyrant.MRDB;
import tokyotyrant.networking.NodeAddress;

/**
*
* blog http://www.micmiu.com
*
* @author Michael
*
*/
public class MRDBExample {

/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {

MRDB db = null;
try {
db = new MRDB();
// connect to the server
db.open(NodeAddress.addresses("tcp://192.168.126.134:1978"));
Object value;
// store records
if (db.await(db.put("my_firstname", "Sun"))) {
System.out.println("MRDB put my_firstname successful.");
} else {
System.out.println("MRDB put my_firstname error.");
}

if (db.await(db.put("my_lastname", "Michael"))) {
System.out.println("MRDB put my_lastname successful.");
} else {
System.out.println("MRDB put my_lastname error.");
}

if (db.await(db.put("my_blogurl", "www.micmiu.com"))) {
System.out.println("MRDB put my_blogurl successful.");
} else {
System.out.println("MRDB put my_blogurl error.");
}

if (db.await(db.put("my_weibo", "www.sina.com/ctosun"))) {
System.out.println("MRDB put my_weibo successful.");
} else {
System.out.println("MRDB put my_weibo error.");
}

// retrieve records
value = db.await(db.get("my_blogurl"));
System.out.println("test_blogurl =: " + value);

value = db.await(db.get("test_noexit"));
System.out.println("test_noexit =: " + value);

System.out.println("===== test repeat put ");
db.put("test_desc", "hello world");
System.out.println("test_desc =: " + db.await(db.get("test_desc")));
db.put("test_desc", "repeat put value is hello Michael");
System.out.println("test_desc =: " + db.await(db.get("test_desc")));

// add int
db.put("int_i", 4);
// add double
db.put("dou_d", 8.8D);

// Initialize the iterator
System.out.println("===== access all key ");
Object[] keys = db
.await(db.fwmkeys("", db.size().get().intValue()));
for (Object keyObj : keys) {
System.out.println(keyObj + " =: " + db.await(db.get(keyObj)));
}

} catch (Exception e) {
e.printStackTrace();
} finally {
// close the connection
db.close();
}
}
}
[/java]
运行结果:

[16:42:42] INFO [tokyotyrant.networking.nio.NioNode] – Connect tcp://192.168.126.134:1978
MRDB put my_firstname successful.
MRDB put my_lastname successful.
MRDB put my_blogurl successful.
MRDB put my_weibo successful.
test_blogurl =: www.micmiu.com
test_noexit =: null
===== test repeat put
test_desc =: hello world
test_desc =: repeat put value is hello Michael
===== access all key
my_firstname =: Sun
my_lastname =: Michael
my_blogurl =: www.micmiu.com
my_weibo =: www.sina.com/ctosun
int_i =: 4
test_desc =: repeat put value is hello Michael
dou_d =: 8.8
[16:42:42] INFO [tokyotyrant.networking.nio.NioNode] – Disconnect tcp://192.168.126.134:1978
[16:42:42] INFO [tokyotyrant.networking.nio.NioNetworking] – Stopped. So will not handle IO. 0 keys will be ignored
————————

转自:http://www.micmiu.com/nosql/tokyotyrant-java-client/

TOKYOTYRANT 队列服务器【转】

Tokyo Tyrant最常用的功能就是提供key->value的数据存储服务,再加上Tokyo Tyrant的lua语言扩展就可以实现很多适合自己需求的功能,例如:定时清理缓存数据(ttserver本身并不去管数据的过期时间,当然它采用的是磁盘存储,可以有很大的空间用来存放数据,不必去管数据的过期);session服务器;队列服务器;记数器等等!

下面就来说一说,如何用Tokyo Tyrant构建一个队列服务器:

1. 安装

复制代码
#安装 Tokyo Cabinet

wget http://1978th.net/tokyocabinet/tokyocabinet-1.4.45.tar.gz
tar zxvf tokyocabinet-1.4.45.tar.gz
cd tokyocabinet-1.4.45
./configure –enable-off64
#32位系统需要 –enable-off64,以让它支持大于2GB的文件
make
make install

cd ../

#ttserver运行时,支持一些扩展脚本,这里采用lua脚本,所以需要lua的支持,安装 lua
wget http://www.lua.org/ftp/lua-5.1.4.tar.gz
tar zxvf lua-5.1.4.tar.gz
cd lua-5.1.4.tar.gz
#要根据系统而定,直接make它会有提示
make linux
make install
ln -s /usr/local/bin/lua /usr/bin/lua

cd ../
#安装Tokyo Cabinet 的 lua 扩展
wget http://1978th.net/tokyocabinet/luapkg/tokyocabinet-lua-1.9.tar.gz
tar zxvf tokyocabinet-lua-1.9.tar.gz
cd tkoyocabinet-lua-1.9.tar.gz
./configure
make
make install

cd ../

//安装 Tokyo Tyrant
wget http://1978th.net/tokyotyrant/tokyotyrant-1.1.40.tar.gz
tar zxvf tokyotyrant-1.1.40.tar.gz
./configure –enable-lua –with-lua
make
make install

cd ../

复制代码

 

2. 配置

在 tokyo tyrant 的源码目录下有一个 ext 文件夹,里面存放的就是一些 lua 扩展脚本,queue.lua 就是用来提供队列服务的,这里我将 queue.lua 复制到 /etc/ttserver 里面去,打开该脚本,里面提供三个函数,主要是:

enqueue(key, value),进队列,key为队列名称,value为队列值。

dequeue(key, max),出队列,key为队列名称,max为每次从队列中取出多少条记录。

queuesize(key),队列的长度,key为队列名称。

3. 启动

#ttserver -host 127.0.0.1 -port 11221 -thnum 8 -dmn -pid /data/ttserver/my_queue/ttserver.pid -log
/data/ttserver/my_queue/ttserver.log -le -ulog /data/ttserver/my_queue/ -ulim 32m -sid 1 -rts
/data/ttserver/my_queue/ttserver.rts -ext /etc/ttserver/queue.lua
/data/ttserver/my_queue/database.tch

 

 

TokyoTyrant 队列服务器

启动参数说明可以参考这里:http://blog.s135.com/post/362/

4. 测试

向队列服务器里插入一条记录,my_queue为队列名,hello是记录值。如果插入成功就会返回:ok

#tcrmgr ext 127.0.0.1:11221 enqueue my_queue hello

 

从队列服务器里取出一条记录,my_queue为队列名,1为只取一条记录。返回队列头部的第一条记录值。

#tcrmgr ext 127.0.0.1:11221 dequeue my_queue 1

 

TokyoTyrant 队列服务器

5. 客户端访问

一般在web中有很多需要用到队列的地方,刚好,演示一下如何用tokyo tyrant为PHP提供队列服务。

我这里用到的是PHP版本的 tokyo tyrant 客户端,如果想用so版本的,就需要去http://pecl.php.net/package/tokyo_tyrant 下载后编译安装,这里我以 php 版的客户端测试。

循环向队列写入100条记录,并一次取出10条记录,代码如下:

复制代码
<?php
include(‘Tyrant/Tyrant.php’);

$tt = Tyrant::connect(’127.0.0.1′, ’11221′);

for($i=1; $i<=100; $i++)
{
$tt->ext(‘enqueue’, ’my_queue’, $i, 0);
}

var_dump($tt->ext(‘dequeue’, ’my_queue’, 10, 0));

//上面ext方法的最后一个参数0,为是否开启锁机制,还有下面两个值可选:
//一个相当于行锁,一个相当于表锁,一般第一个就够用了
//Tyrant::XOLCKREC for record locking
//Tyrant::XOLCKGLB for global locking
?>

复制代码

 

运行结果:

TokyoTyrant 队列服务器

返回的值是一个字符串,每条记录之间用”\n”分隔,最后也有一个”\n”。

接着再通过 tcrmgr 去队列中取出10条记录:

TokyoTyrant 队列服务器

队列服务器搭建完毕,以ttserver一直以来的表现,效率方面应该不是问题,这里我也没有进行大量的这方面的测试。

MongoDB vs Redis vs Tokyo Tyrant[转]

准备对MongoDB, Redis以及Tokyo Tyrant的读写做一个简单的测试,为了进行相对公平的测试,需要了解他们背后的实现机制,下面是一些比较:

存储实现的比较:
* 内存文件映像(Memory-File Mapping) Redis, MongoDB
* 文件 + Cache Tokyo Tyrant
* 内存: Redis, Tokyo Tyrant
Key/Value索引形式:
* B+ Tree : MongoDB, Tokyo Tyrant
* Hash Table: Redis, Tokyo Tyrant
* Fixed Length: Tokyo Tyrant

从上面的比较可以看出,Redis和MongoDB是基于系统内存映像文件,数据能命中在内存的时候读写操作性能应该是非常强的,当然,反过来,如果数据十分分散不能在内存命中,那么内存页的切换开销将是非常可怕的,MongoDB和Redis数据文件不同的是将数据存放在多个文件中,每当上一个存满的时候就会创建新的数据空间文件。鉴于MongoDB 是主要比较对象,而其采用B+Tree进行存储,故TT也使用B+Tree引擎进行比较。

那么该测试什么自然就可以得知:尽管使用内存映像文件读写操作会很快(快到什么程度),但是当写满内存以后呢?

文件大小限制:
32bit: MongoDB <= 2G
TT no limits if u ./configure –enable-off
64bit: MongoDB和TT均无限制。

注:Redis 总是受限于内存的大小。

为了进行相对公平的测试:
首先通过虚拟机对内存的使用进行同等限制,因为MongoDB和Redi实际上读写都是在内存操作的(利用MemoryMap文件),故当数据库的大小超过内存大小时候的性能尤为重要。故用虚拟机来设置一个较小的内存大小,来快速观察数据库大小超过内存的时候的性能。
这里设置虚拟机内存256M,实际可使用内存200M左右,CPU 2核,Unbuntu Server 9.10

测试记录:
Key: 512的随机字符串
Value: 大约5k的随机字符串
每项记录数据大小:大约5.5k
计划插入数据100000条:5.5k*1000=5.5M*100=550M 数据量大约 550M。

注:key开始是用1k的随机字符串来测试,但是在测试mongoDB 报告key too large to index, 因此减小key的大小到512字节。

当没有任何数据的时候:
MongoDB的大小:
64M: (db.0, db.1, ..)data FIle
16M: (database.ns) name space index file.

TC的大小:
133K btree.tcb
256 fixed.tcf
517K hash.tch

Redis的大小:
VirtualMemFile: 41M redis-3546.vm
DB: 0M
注:redis的文件初始大小基本等于你设置的内存以及内存页的大小,可以自己调整。redis通过定时存盘的策略进行保存,定时策略可以自行设置。
通常情况下,redis的数据库必须<=内存,如果要让redis的数据库大于内存,那么必须在配置中打开vm_enabled选项(貌似没用,当插入数据超过内存后,会被Unbuntu的后台保护进程给杀掉,如果设置了最大使用的内存,则数据已有记录数达到内存限值后不能继续插入新值)。

key/value 功能:
Redis: 读写key/value,value可以有各种结构,但Value无索引。
MongoDB: 以collection组织,key如果不特别指定将由系统作为ObjectId产生(指定使用“_id”字段),value是结构化的,value里的字段可以被索引。
TokyoTyrant: 读写key/value,table 数据引擎支持结构化的value和字段索引,其它数据引擎不支持,b+tree可以用key索引。

基准测试机器:
虚拟机是跑在 2 CPU 2.26G Intel Core 2 Duo,内存为2G
虚拟机:
CPU 2核
内存 256M
操作系统:Unbuntu Server 9.10 32bit

使用软件版本:
* MongoDB: mongodb-linux-i686-2010-02-26
* TokyoTyrant: TT1.1.40; TC1.4.42
* Redis: 2010-03-01(GIT SRC)

启动:
redis-server ./redis.conf(设置了最大内存210兆:maxmemory 210000000, vm-enable=yes,vm-max-memory 20000000,vm-pages 1342177)
./ttserver -port 1974 /data/db/tt.tcb
bin/mongod -port 1974 –dbpath /data/db/mongo

MongoDB
如上所述测试添加10万条数据:
内存,刚开始的时候虚拟内存占用48564,物理内存占用 3432,在插入2000条数据后,虚拟内存到达143M,物理内存33M,内存增长很迅速。最后虚拟内存稳定在1048M,物理内存则在160M-211M徘徊。
CPU占用率最低的时候为6%,最高的时候达到30%,平时在8%-10%之间。
从测试看,每次分配DB空间的时候所有插入操作被冻结,最坏的一次插入2000条耗时1分多(这个时候正好有分配空间文件发生),平时,插入2000条数据大约耗时17-18秒。
最后MongoDB的数据文件总大小达到:977M

接着测试MongoDB读取10万条记录(非命中形式:该key是随机产生的,因此大都不会存在数据库中)

内存:虚拟内存稳定在1048M,物理内存占用在90M-94M。
CPU:最低占用8%,最高到45%;平时在10%-12%左右。
读取2000条记录大约耗时3-4秒,第一次用了6秒。

Redis
同样测试添加10万条数据:
内存,开始的时候忘记看了,大致较开始的虚拟内存占用112M,物理内存82M,在4万条记录的时候VM占用196M,物理内存占用163M,最后的时候VM占用237M,物理内存204M。
CPU:最低占用3%,最高的时候15%,平时在7%-11%之间。
当Redis向磁盘写入数据的时候,有变慢(2000条记录耗时21秒),平时存2000条记录大约耗时18-19秒左右。
不过没有设定maxmemory的时候,在大约写入 6万多个数据后服务器被挂掉。当设置最大使用内存(200M)后,达到内存限制,写入不了(已写入48136个数据),但是不会挂了。
Redis文件在写入48136个数据时候的大小(包括VM文件):277M,其中VM 41M,数据库236M。

接着测试Redis读取10万条记录(非命中形式:该key大都不会存在数据库中)
内存:虚拟内存237M,物理内存占用204M
CPU:在26%-43%

读取2000条记录大约耗时在3-4秒。

Tokyo Tyrant
如上所述测试添加10万条数据:采用默认配置参数运行TT B+Tree
内存:初始的时候VM: 76928 物理内存: 1232,在插入的过程内存的增加很少,在插入到4万条记录的时候虚拟内存仅为99540,物理内存23M,到最后虚拟内存117M,物理内存37M。
CPU占用率始终稳定在2%

在插入到5万条记录前,平均插入2000条耗时约19-20秒,到8万条记录前时候,插入2000条耗时20-22秒,再接下来的2万条,平均插入2000条耗时在慢慢增加并有震荡,28秒,最后到42秒(B+Tree的索引节点在内存中满了?可能需要调整参数?)。
TT的数据库只有一个文件大小为:589M

接着测试TT读取10万条记录(非命中形式:该key大都不会存在数据库中)
内存稳定在:VM110M;物理内存36M。
CPU:最低2%,最高6%,平时在4%

读取2000条记录大约耗时在7-8秒,偶尔6秒或9秒。

小结:
MongoDB和Redis写入数据不是直接写入磁盘,所以当重启系统时候没有存盘的数据将全部丢失。TT实际上也有内存缓冲,不过和前者相比要小的多。
以上测试并不完善,只是一个开始,比如没有测试小数据(以数字作为key,100字节Value),没有测试较大的数据(20K左右);没有测试在命中情况下的性能;没有测试并发读写的性能,据闻MongoDB的并发读写效率不是特别出色,MongoDB的特色在于支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,并实现了存储节点的自动sharding管理等配套功能;以及由于MongoDB是分布在多个文件中,当数据量远大内存,分布在足够多的文件的时候的性能;对开启同步日志后的Replication测试….对于TT来说,需要对TT的其它数据引擎进行测试,以及TT的各种数据引擎如何优化?TC/TT在mixi的实际应用当中,存储了2000万条以上的数据,同时支撑了上万个并发连接,是一个久经考验的项目。TC在保证了极高的并发读写性能的同时,具有可靠的数据持久化机制,同时还支持类似关系数据库表结构的hashtable以及简单的条件,分页和排序操作,是一个很棒的NoSQL数据库。TC的主要缺点是在数据量达到上亿级别以后,并发写数据性能会大幅度下降(读不受影响),NoSQL: If Only It Was That Easy提到,他们发现在TC里面插入1.6亿条2-20KB数据的时候,写入性能开始急剧下降。Redis本质上是一个Key-Value类型的内存数据库,很像memcached,整个数据库统统加载在内存当中进行操作,定期通过异步操作把数据库数据flush到硬盘上进行保存。因为是纯内存操作,Redis的性能非常出色,Redis最大的魅力是支持保存List链表和Set集合的数据结构,而且还支持对List进行各种操作,例如从List两端push和pop数据,取 List区间,排序等等,对Set支持各种集合的并集交集操作,此外单个value的最大限制是1GB,不像memcached只能保存1MB的数据,Redis可以用来实现很多有用的功能,比方说用他的List来做FIFO双向链表,实现一个轻量级的高性能消息队列服务,用他的Set可以做高性能的tag系统等等。另外Redis也可以对存入的Key-Value设置expire时间,因此也可以被当作一个功能加强版的memcached来用。

测试程序和详细记录见附件: testbench.tgz.zip

Refs:
* http://porteightyeight.com/2009/11/09/redis-benchmarking-on-amazon-ec2-flexiscale-and-slicehost/
* http://www.eb163.com/club/viewthread.php?tid=2470
* http://timyang.net/data/mcdb-tt-redis/
* http://www.javaeye.com/topic/524977
* http://bjclark.me/2009/08/04/nosql-if-only-it-was-that-easy/

摘自:http://www.cnblogs.com/riceball/archive/2010/03/05/MongoDB_Vs_Redis_Vs_TokyoTyrant.html

redis访问加密码的问题

1. 改配置

# requirepass foobared 去掉注释,foobared改为 自己的password
2.启动
/usr/local/redis/src/redis-server -p 6380
3.测试
/usr/local/redis/src/redis-cli -p 6380 -a password
redis>set a b
(error) ERR operation not permitted
看样子-a 不是设置没起作用
redis>auth password
redis>set a b
ok

Redis使用系列:配置文件篇[转]

如果认为Redis是一个key value存储, 可以使用它来代替MySQL;如果认为它是一个可以持久化的cache, 可能只是用它保存一些频繁访问的临时数据(代替Memcached);除此之外,还可以把Redis当做一个轻量级的消息队列使用,因为它内置就支持 list数据结构和PUB/SUB命令;还可以当做一个轻量级的分布式锁系统。Redis是REmote DIctionary Server的缩写,在Redis在官方网站的解释是:

Redis is an open source, advanced key-value store.
It is often referred to as a data structure server since keys
can contain strings, hashes, lists, sets and sorted sets.

本文将会详细介绍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 <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. 指定本地数据库存放目录

dir ./

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的内存。

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

本文完整的介绍了Redis配置文件,希望对大家有用。