月度归档:2012 年九月

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