中文字幕亚洲欧美,91国产在线播放,精品三区视频

REDIS监控

paulwong — Mon, 19 Oct 2015 04:39:00 GMT

http://git.oschina.net/hellovivi/RedisFlag

paulwong 2015-10-19 12:39 发表评论

paulwong — Wed, 25 Feb 2015 02:02:00 GMT

1 ��d��redis支持

在pom.xml中添�?/p>

Xml代码  
<dependency>  
          <groupId>org.springframework.bootgroupId>  
          <artifactId>spring-boot-starter-redisartifactId>  
      dependency>  

2 redis配置

Java代码  
@Configuration  
@EnableCaching  
public class RedisCacheConfig {  
    @Bean  
    public CacheManager cacheManager(  
            @SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {  
        return new RedisCacheManager(redisTemplate);  
    }  
  
    @Bean  
    public RedisTemplate redisTemplate(  
            RedisConnectionFactory factory) {  
        final StringRedisTemplate template = new StringRedisTemplate(factory);  
        template.setValueSerializer(new Jackson2JsonRedisSerializer(  
                SysUser.class)); //��h��意这�?/span>  
  
        return template;  
    }  
}  

3 redis服务器配�|?/h1>
Properties代码
# REDIS (RedisProperties)
spring.redis.database= # database name
spring.redis.host=localhost # server host
spring.redis.password= # server password
spring.redis.port=6379 # connection port
spring.redis.pool.max-idle=8 # pool settings ...
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.sentinel.master= # name of Redis server
spring.redis.sentinel.nodes= # comma-separated list of host:port pairs

4 应用

Java代码  
/** 
*此处的dao操作使用的是spring data jpa,使用@Cacheable可以在�Q意方法上�Q?比如@Service或者@Controller的方法上 
*/  
public interface SysUserRepo1 extends CustomRepository {  
    @Cacheable(value = "usercache")  
    public SysUser findByUsername(String username);  
}  

5 ��?/h1>
Java代码
@Controller
public class TestController {


    @Autowired
    SysUserRepo1 sysUserRepo1;
    @RequestMapping("/test")
    public @ResponseBody String test(){

        final SysUser loaded = sysUserRepo1.findByUsername("wyf");
        final SysUser cached = sysUserRepo1.findByUsername("wyf");

        return "ok";
    }
}

效果如图�Q?/p>

paulwong 2015-02-25 10:02 发表评论

几大NOSQL数据库性能比较

paulwong — Thu, 29 Jan 2015 16:16:00 GMT

Apache Cassandra NoSQL Performance Benchmarks
http://planetcassandra.org/nosql-performance-benchmarks

NoSQL Benchmarking
http://www.cubrid.org/blog/dev-platform/nosql-benchmarking/

http://www.badrit.com/blog/2013/11/18/redis-vs-mongodb-performance#.VMpfW2SUfsg

How many requests per second can I get out of Redis?
http://skipperkongen.dk/2013/08/27/how-many-requests-per-second-can-i-get-out-of-redis/

redis性能��试�Q�测试�ƈ发性能
http://my.oschina.net/pblack/blog/102394

paulwong 2015-01-30 00:16 发表评论

Architecture for Redis cache & Mongo for persistence

paulwong — Sun, 04 Jan 2015 07:50:00 GMT

Caching with Spring Data Redis
http://www.javacodegeeks.com/2013/02/caching-with-spring-data-redis.html

Architecture for Redis cache & Mongo for persistence
http://stackoverflow.com/questions/11218941/architecture-for-redis-cache-mongo-for-persistence

MongoDB with redis
http://stackoverflow.com/questions/10696463/mongodb-with-redis/10721249#10721249

Caching Data in Spring Using Redis
http://caseyscarborough.com/blog/2014/12/18/caching-data-in-spring-using-redis/

Springside Redis
https://github.com/springside/springside4/wiki/Redis

Spring Cache注解+Redis
http://hanqunfeng.iteye.com/blog/2176172

paulwong 2015-01-04 15:50 发表评论

SPRING-SESSION

paulwong — Wed, 19 Nov 2014 10:23:00 GMT

摘要: HTTP SESSION的管理通常是由容器来做�Q�但如果是在PAAS环境下，服务器不能做变更�Q�则需要由WEB应用来做处理HTTP SESSION。同��P��如果是分布式的环境下�Q�SESSION的管理也会带来性能问题。SPRING推出了处理SESSION的框�Ӟ��SPRING-SESSION�? SPRING会重写HTTP SESSION的那一套，使用SESSION也同栯��是用 Code ... 阅读全文

paulwong 2014-11-19 18:23 发表评论

Redis 集群解决�Ҏ�� Codis

paulwong — Sun, 09 Nov 2014 01:28:00 GMT

https://github.com/wandoulabs/codis

Codis 是一个分布式 Redis 解决�Ҏ��, 对于上层的应用来�? �q�接�?Codis Proxy 和连接原生的 Redis Server 没有明显的区�?(不支持的命��o列表), 上层应用可以像��用单机的 Redis 一样��? Codis 底层会处理请求的转发, 不停机的数据�q�移�{�工�? 所有后边的一切事�? 对于前面的客��L��来说是透明�? 可以��单的认�ؓ后边�q�接的是一个内存无限大�?Redis 服务.

Codis 由四部分�l�成:

Codis Proxy (codis-proxy)
Codis Manager (codis-config)
Codis Redis (codis-server)
ZooKeeper

codis-proxy 是客��L��q�接�?Redis 代理服务, codis-proxy 本��n实现�?Redis 协议, 表现得和一个原生的 Redis 没什么区�?(��像 Twemproxy), 对于一个业务来�? 可以部��v多个 codis-proxy, codis-proxy 本��n是无状态的.

codis-config �?Codis 的管理工�? 支持包括, ��d��/删除 Redis 节点, ��d��/删除 Proxy 节点, 发�v数据�q�移�{�操�? codis-config 本��n�q�自带了一�?http server, 会启动一�?dashboard, 用户可以直接在浏览器上观�?Codis 集群的运行状�?

codis-server �?Codis ��目�l�护的一�?Redis 分支, ��Z�� 2.8.13 开�? 加入�?slot 的支持和原子的数据迁�U�L��? Codis 上层�?codis-proxy �?codis-config 只能和这个版本的 Redis 交互才能正常�q�行.

Codis 依赖 ZooKeeper 来存放数据�\��p��?codis-proxy 节点的元信息, codis-config 发�v的命令都会通过 ZooKeeper 同步到各个存�zȝ�� codis-proxy.

Codis 支持按照 Namespace 区分不同的��? 拥有不同�?product name 的��? 各项配置都不会冲�H?

目前 Codis 已经是稳定阶�D�，目前豌豆�?/a>已经在��用该�pȝ��?/p>

架构�Q?/p>

�Ҏ��：

自动�q��
使用非常��?/p>
囑�Ş化的面板和管理工�?/p>
支持�l�大多数 Redis 命��o�Q�完全兼�?nbsp;twemproxy
支持 Redis 原生客户�?/p>
安全而且透明的数据移植，可根据需要轻松添加和删除节点
提供命��o行接�?/p>
RESTful APIs

安装�Q?/p>

Install go
go get github.com/wandoulabs/codis
cd codis
./bootstrap.sh
make gotest
cd sample
follow instructions in usage.md

界面截图�Q?/p>

Dashboard

Migrate

Slots

paulwong 2014-11-09 09:28 发表评论

Redis的Java客户端Jedis的八�U�调用方�?事务、管道、分布式)介绍

paulwong — Thu, 11 Sep 2014 12:33:00 GMT

在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比：

一、普通同步方�?/h3>

最��单和基础的调用方式，

@Test public void test1Normal() {     Jedis jedis = new Jedis("localhost");     long start = System.currentTimeMillis();     for (int i = 0; i < 100000; i++) {         String result = jedis.set("n" + i, "n" + i);     }     long end = System.currentTimeMillis();     System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");     jedis.disconnect(); }

很简单吧�Q�每��?code style="padding: 1px 3px; margin: 0px 2px; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, 'monospace !important'; border: 1px solid #eeeeee; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; word-break: break-all; color: #40aa53; background-color: #fcfcfc;">set之后都可以返回结果，标记是否成功�?/p>

二、事务方�?Transactions)

redis的事务很��单，他主要目的是保障�Q�一个client发�v的事务中的命令可以连�l�的执行�Q�而中间不会插入其他client的命令�?/p>

看下面例子：

@Test public void test2Trans() {     Jedis jedis = new Jedis("localhost");     long start = System.currentTimeMillis();     Transaction tx = jedis.multi();     for (int i = 0; i < 100000; i++) {         tx.set("t" + i, "t" + i);     }     List results = tx.exec();     long end = System.currentTimeMillis();     System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");     jedis.disconnect(); }

我们调用jedis.watch(…)�Ҏ��来监控key�Q�如果调用后key值发生变化，则整个事务会执行��p�|。另外，事务中某个操作失败，�q�不会回滚其他操作。这一炚w��要注意。还有，我们可以使用discard()�Ҏ��来取消事务�?/p>

三、管�?Pipelining)

有时�Q�我们需要采用异步方式，一�ơ发送多个指令，不同步等待其�q�回�l�果。这样可以取得非常好的执行效率。这��是��道�Q�调用方法如下：

@Test public void test3Pipelined() {     Jedis jedis = new Jedis("localhost");     Pipeline pipeline = jedis.pipelined();     long start = System.currentTimeMillis();     for (int i = 0; i < 100000; i++) {         pipeline.set("p" + i, "p" + i);     }     List results = pipeline.syncAndReturnAll();     long end = System.currentTimeMillis();     System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");     jedis.disconnect(); }

四、管道中调用事务

��Jedis提供的方法而言�Q�是可以做到在管道中使用事务�Q�其代码如下�Q?/p>

@Test public void test4combPipelineTrans() {     jedis = new Jedis("localhost");      long start = System.currentTimeMillis();     Pipeline pipeline = jedis.pipelined();     pipeline.multi();     for (int i = 0; i < 100000; i++) {         pipeline.set("" + i, "" + i);     }     pipeline.exec();     List results = pipeline.syncAndReturnAll();     long end = System.currentTimeMillis();     System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");     jedis.disconnect(); }

但是�l�测试（见本文后�l�部分）�Q�发现其效率和单独��用事务差不多�Q�甚臌��略微差点�?/p>

五、分布式直连同步调用

@Test public void test5shardNormal() {     List shards = Arrays.asList(             new JedisShardInfo("localhost",6379),             new JedisShardInfo("localhost",6380));      ShardedJedis sharding = new ShardedJedis(shards);      long start = System.currentTimeMillis();     for (int i = 0; i < 100000; i++) {         String result = sharding.set("sn" + i, "n" + i);     }     long end = System.currentTimeMillis();     System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");      sharding.disconnect(); }

�q�个是分布式直接�q�接�Q��ƈ且是同步调用�Q�每步执行都�q�回执行�l�果。类似地�Q�还有异步管道调用�?/p>

六、分布式直连异步调用

@Test public void test6shardpipelined() {     List shards = Arrays.asList(             new JedisShardInfo("localhost",6379),             new JedisShardInfo("localhost",6380));      ShardedJedis sharding = new ShardedJedis(shards);      ShardedJedisPipeline pipeline = sharding.pipelined();     long start = System.currentTimeMillis();     for (int i = 0; i < 100000; i++) {         pipeline.set("sp" + i, "p" + i);     }     List results = pipeline.syncAndReturnAll();     long end = System.currentTimeMillis();     System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");      sharding.disconnect(); }

七、分布式�q�接池同步调�?/h3>

如果�Q�你的分布式调用代码是运行在�U�程中，那么上面两个直连调用方式��׃��合适了�Q�因为直�q�方式是非线�E�安全的�Q�这个时候，你就必须选择�q�接池调用�?/p>

@Test public void test7shardSimplePool() {     List shards = Arrays.asList(             new JedisShardInfo("localhost",6379),             new JedisShardInfo("localhost",6380));      ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);      ShardedJedis one = pool.getResource();      long start = System.currentTimeMillis();     for (int i = 0; i < 100000; i++) {         String result = one.set("spn" + i, "n" + i);     }     long end = System.currentTimeMillis();     pool.returnResource(one);     System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");      pool.destroy(); }

上面是同步方式，当然�q�有异步方式�?/p>

八、分布式�q�接池异步调�?/h3>

@Test public void test8shardPipelinedPool() {     List shards = Arrays.asList(             new JedisShardInfo("localhost",6379),             new JedisShardInfo("localhost",6380));      ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);      ShardedJedis one = pool.getResource();      ShardedJedisPipeline pipeline = one.pipelined();      long start = System.currentTimeMillis();     for (int i = 0; i < 100000; i++) {         pipeline.set("sppn" + i, "n" + i);     }     List results = pipeline.syncAndReturnAll();     long end = System.currentTimeMillis();     pool.returnResource(one);     System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");     pool.destroy(); }

九、需要注意的地方

事务和管道都是异步模式。在事务和管道中不能同步查询�l�果。比如下面两个调用，都是不允许的�Q?/p>

 Transaction tx = jedis.multi();  for (int i = 0; i < 100000; i++) {      tx.set("t" + i, "t" + i);  }  System.out.println(tx.get("t1000").get());  //不允�?  List results = tx.exec();   …  …   Pipeline pipeline = jedis.pipelined();  long start = System.currentTimeMillis();  for (int i = 0; i < 100000; i++) {      pipeline.set("p" + i, "p" + i);  }  System.out.println(pipeline.get("p1000").get()); //不允�?  List results = pipeline.syncAndReturnAll();

事务和管道都是异步的�Q�个人感觉，在管道中再进行事务调用，没有必要�Q�不如直接进行事务模式�?/p>
分布式中�Q�连接池的性能比直�q�的性能略好(见后�l�测试部�?�?/p>
分布式调用中不支持事务�?/p>
因�ؓ事务是在服务器端实现�Q�而在分布式中�Q�每�Ҏ��的调用对象都可能讉K��不同的机器，所以，没法�q�行事务�?/p>

十、测�?/h3>

�q�行上面的代码，�q�行��试�Q�其�l�果如下�Q?/p>

Simple SET: 5.227 seconds  Transaction SET: 0.5 seconds Pipelined SET: 0.353 seconds Pipelined transaction: 0.509 seconds  Simple@Sharing SET: 5.289 seconds Pipelined@Sharing SET: 0.348 seconds  Simple@Pool SET: 5.039 seconds Pipelined@Pool SET: 0.401 seconds

另外�Q�经��试分布式中用到的机器越多，调用会越慢。上面是2片，下面�?片：

Simple@Sharing SET: 5.494 seconds Pipelined@Sharing SET: 0.51 seconds Simple@Pool SET: 5.223 seconds Pipelined@Pool SET: 0.518 seconds

下面�?0片：

Simple@Sharing SET: 5.9 seconds Pipelined@Sharing SET: 0.794 seconds Simple@Pool SET: 5.624 seconds Pipelined@Pool SET: 0.762 seconds

下面�?00片：

Simple@Sharing SET: 14.055 seconds Pipelined@Sharing SET: 8.185 seconds Simple@Pool SET: 13.29 seconds Pipelined@Pool SET: 7.767 seconds

分布式中�Q�连接池方式调用不但�U�程安全外，�Ҏ��上面的测试数据，也可以看��接池比直�q�的效率更好�?/p>

十一、完整的��试代码

package com.example.nosqlclient;  import java.util.Arrays; import java.util.List;  import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test;  import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPoolConfig; import redis.clients.jedis.JedisShardInfo; import redis.clients.jedis.Pipeline; import redis.clients.jedis.ShardedJedis; import redis.clients.jedis.ShardedJedisPipeline; import redis.clients.jedis.ShardedJedisPool; import redis.clients.jedis.Transaction;  import org.junit.FixMethodOrder; import org.junit.runners.MethodSorters;  @FixMethodOrder(MethodSorters.NAME_ASCENDING) public class TestJedis {      private static Jedis jedis;     private static ShardedJedis sharding;     private static ShardedJedisPool pool;      @BeforeClass     public static void setUpBeforeClass() throws Exception {         List shards = Arrays.asList(                 new JedisShardInfo("localhost",6379),                 new JedisShardInfo("localhost",6379)); //使用相同的ip:port,仅作���试           jedis = new Jedis("localhost");          sharding = new ShardedJedis(shards);          pool = new ShardedJedisPool(new JedisPoolConfig(), shards);     }      @AfterClass     public static void tearDownAfterClass() throws Exception {         jedis.disconnect();         sharding.disconnect();         pool.destroy();     }      @Test     public void test1Normal() {         long start = System.currentTimeMillis();         for (int i = 0; i < 100000; i++) {             String result = jedis.set("n" + i, "n" + i);         }         long end = System.currentTimeMillis();         System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");     }      @Test     public void test2Trans() {         long start = System.currentTimeMillis();         Transaction tx = jedis.multi();         for (int i = 0; i < 100000; i++) {             tx.set("t" + i, "t" + i);         }         //System.out.println(tx.get("t1000").get());          List results = tx.exec();         long end = System.currentTimeMillis();         System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");     }      @Test     public void test3Pipelined() {         Pipeline pipeline = jedis.pipelined();         long start = System.currentTimeMillis();         for (int i = 0; i < 100000; i++) {             pipeline.set("p" + i, "p" + i);         }         //System.out.println(pipeline.get("p1000").get());         List results = pipeline.syncAndReturnAll();         long end = System.currentTimeMillis();         System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");     }      @Test     public void test4combPipelineTrans() {         long start = System.currentTimeMillis();         Pipeline pipeline = jedis.pipelined();         pipeline.multi();         for (int i = 0; i < 100000; i++) {             pipeline.set("" + i, "" + i);         }         pipeline.exec();         List results = pipeline.syncAndReturnAll();         long end = System.currentTimeMillis();         System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");     }      @Test     public void test5shardNormal() {         long start = System.currentTimeMillis();         for (int i = 0; i < 100000; i++) {             String result = sharding.set("sn" + i, "n" + i);         }         long end = System.currentTimeMillis();         System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");     }      @Test     public void test6shardpipelined() {         ShardedJedisPipeline pipeline = sharding.pipelined();         long start = System.currentTimeMillis();         for (int i = 0; i < 100000; i++) {             pipeline.set("sp" + i, "p" + i);         }         List results = pipeline.syncAndReturnAll();         long end = System.currentTimeMillis();         System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");     }      @Test     public void test7shardSimplePool() {         ShardedJedis one = pool.getResource();          long start = System.currentTimeMillis();         for (int i = 0; i < 100000; i++) {             String result = one.set("spn" + i, "n" + i);         }         long end = System.currentTimeMillis();         pool.returnResource(one);         System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");     }      @Test     public void test8shardPipelinedPool() {         ShardedJedis one = pool.getResource();          ShardedJedisPipeline pipeline = one.pipelined();          long start = System.currentTimeMillis();         for (int i = 0; i < 100000; i++) {             pipeline.set("sppn" + i, "n" + i);         }         List results = pipeline.syncAndReturnAll();         long end = System.currentTimeMillis();         pool.returnResource(one);         System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");     } }

paulwong 2014-09-11 20:33 发表评论

��Z��么��?Redis及其产品定位

paulwong — Tue, 26 Aug 2014 01:04:00 GMT

传统MySQL+ Memcached架构遇到的问�?/h2>
实际MySQL是适合�q�行��量数据存储的，通过Memcached��热�Ҏ��据加载到cache�Q�加速访问，很多公司都曾�l��用过�q�样的架构，但随着业务数据量的不断增加�Q�和讉K��量的持箋增长�Q�我们遇��C��很多问题�Q?/p>
MySQL需要不断进行拆库拆表，Memcached也需不断跟着扩容�Q�扩容和�l�护工作占据大量开发时间�?/p>
Memcached与MySQL数据库数据一致性问题�?/p>
Memcached数据命中率低或down机，大量讉K��直接�I�K��到DB�Q�MySQL无法支撑�?/p>
跨机房cache同步问题�?/p>

众多NoSQL百花齐放�Q�如何选择

最�q�几�q�_��业界不断涌现出很多各�U�各��L��NoSQL产品�Q�那么如何才能正��地使用好这些��品，最大化地发挥其长处�Q�是我们需要深入研�I�和思考的�?题，实际归根�l�底最重要的是了解�q�些产品的定位，�q�且了解到每�ƾ��品的tradeoffs�Q�在实际应用中做到扬镉K��短，��M��上这些NoSQL主要用于解决以下几种问题

��量数据存储�Q�高速读写访问。此�c�M�品通过数据全部in-momery 的方式来保证高速访问，同时提供数据落地的功能，实际�q�正是Redis最主要的适用场景�?/p>
��量数据存储�Q�分布式�pȝ��支持�Q�数据一致性保证，方便的集��节�Ҏ��?删除�?/p>
�q�方面最具代表性的是dynamo和bigtable 2��论文所阐述的思�\。前者是一个完全无中心的设计，节点之间通过gossip方式传递集��信息，数据保证最�l�一致性，后者是一个中心化的方案设计，通过 �c�M��一个分布式锁服务来保证��Z��致�?数据写入先写内存和redo log�Q�然后定期compat归�ƈ到磁盘上�Q�将随机写优化�ؓ��序写，提高写入性能�?/p>
Schema free�Q�auto-sharding�{�。比如目前常见的一些文档数据库都是支持schema-free的，直接存储json格式数据�Q��ƈ且支持auto-sharding�{�功能，比如mongodb�?/p>

面对�q�些不同�c�d��的NoSQL产品,我们需要根据我们的业务场景选择最合适的产品�?/p>

Redis适用场景�Q�如何正��的使用

前面已经分析�q�，Redis最适合所有数据in-momory的场景，虽然Redis也提供持久化功能�Q�但实际更多的是一个disk-backed 的功能，跟传�l�意义上的持久化有比较大的差别，那么可能大家��׃��有疑问，��g��Redis更像一个加强版的Memcached�Q�那么何时��?Memcached,何时使用Redis呢？

Redis与Memcached的比�?/h2>
�|�络IO模型
Memcached是多�U�程�Q�非��d��IO复用的网�l�模型，分�ؓ监听�ȝ��E�和worker子线�E�，监听�U�程监听�|�络�q�接�Q�接受请求后�Q�将�q�接描述字pipe 传递给worker�U�程�Q�进行读写IO, �|�络层��用libevent��装的事件库�Q�多�U�程模型可以发挥多核作用�Q�但是引入了cache coherency和锁的问题，比如�Q�Memcached最常用的stats 命��o�Q�实际Memcached所有操作都要对�q�个全局变量加锁�Q�进行计数等工作�Q�带来了性能损耗�?/p>
�Q�Memcached�|�络IO模型�Q?/p>
Redis使用单线�E�的IO复用模型�Q�自己封装了一个简单的AeEvent事�g处理框架�Q�主要实��C��epoll、kqueue�?select�Q�对于单�U�只有IO操作来说�Q�单�U�程可以��速度优势发挥到最大，但是Redis也提供了一些简单的计算功能�Q�比如排序、聚合等�Q�对于这些操作，单线�E�模型实际会严重影响整体吞吐量，CPU计算�q�程中，整个IO调度都是被阻塞住的�?/p>
内存��理斚w��
Memcached使用预分配的内存池的方式�Q��用slab和大��不同的chunk来管理内存，Item�Ҏ��大小选择合适的chunk�?储，内存池的方式可以省去甌��/释放内存的开销�Q��ƈ且能减小内存��片产生�Q�但�q�种方式也会带来一定程度上的空间浪费，�q�且在内存仍然有很大�I�间�Ӟ��新的�?据也可能会被剔除�Q�原因可以参考Timyang的文章：http://timyang.net/data/Memcached-lru-evictions/
Redis使用现场甌��内存的方式来存储数据�Q��ƈ且很��用free-list�{�方式来优化内存分配�Q�会在一定程度上存在内存��?片，Redis跟据存储命��o参数�Q�会把带�q�期旉��的数据单独存攑֜�一��P��q�把它们�U�Cؓ临时数据�Q�非临时数据是永�q�不会被剔除的，即便物理内存不够�Q�导�?swap也不会剔除�Q何非临时数据�Q�但会尝试剔除部分��时数据）�Q�这点上Redis更适合作�ؓ存储而不是cache�?/p>
数据一致性问�?/p>
Memcached提供了cas命��o�Q�可以保证多个�ƈ发访问操作同一份数据的一致性问题�?Redis没有提供cas 命��o�Q��ƈ不能保证�q�点�Q�不�q�Redis提供了事务的功能�Q�可以保证一�?命��o的原子性，中间不会被�Q何操作打断�?/p>
存储方式及其它方�?/p>
Memcached基本只支持简单的key-value存储�Q�不支持枚�D�Q�不支持持久化和复制�{�功�?/p>
Redis除key/value之外�Q�还支持list,set,sorted set,hash�{�众多数据结构，提供了KEYS
�q�行枚�D操作�Q�但不能在线上��用，如果需要枚丄��上数据，Redis提供了工具可以直接扫描其dump文�g�Q�枚丑և�所有数据，Redis�q�同时提供了持久化和复制�{�功能�?/p>
关于不同语言的客��L��支持
在不同语�a�的客��L��斚w��Q�Memcached和Redis都有丰富的第三方客户端可供选择�Q�不�q�因为Memcached发展的时间更久一些，目前看在客户端支持方面，Memcached的很多客��L��更加成熟�E�_��Q�而Redis�׃��其协议本�w�就比Memcached复杂�Q�加上作者不断增加新的功能等�Q�对应第三方客户端跟�q�速度可能会赶不上�Q�有时可能需要自己在�W�三方客��L��基础上做些修�Ҏ��能更好的使用�?/p>
�Ҏ��以上比较不难看出�Q�当我们不希望数据被�t�出�Q�或者需要除key/value之外的更多数据类型时�Q�或者需要落地功能时�Q��用Redis比��用Memcached更合适�?/p>

关于Redis的一些周边功�?/h2>
Redis除了作�ؓ存储之外�q�提供了一些其它方面的功能�Q�比如聚合计��、pubsub、scripting�{�，对于此类功能需要了解其实现原理�Q�清楚地了解到它的局限性后�Q�才能正��的使用�Q�比如pubsub功能�Q�这个实际是没有��M��持久化支持的�Q�消�Ҏ��q�接闪断或重�q�之间过来的消息是会全部丢失的，又比如聚合计��和scripting�{�功能受Redis单线�E�模型所限，是不可能辑ֈ�很高的吞吐量的，需要�}慎��用�?/p>
�ȝ��来说Redis作者是一位非常勤奋的开发者，可以�l�常看到作者在��试着各种不同的新鲜想法和思�\�Q�针对这些方面的功能��p��求我们需要深入了解后再��用�?/p>

�ȝ��Q?/h2>
Redis使用最��x��式是全部数据in-memory�?/p>
Redis更多场景是作为Memcached的替代者来使用�?/p>
当需要除key/value之外的更多数据类型支持时�Q��用Redis更合适�?/p>
当存储的数据不能被剔除时�Q��用Redis更合适�?/p>
后箋关于Redis文章计划�Q?/p>
Redis数据�c�d��与容量规划�?/p>
如何�Ҏ��业务场景搭徏�E�_��Q�可靠，可扩展的Redis集群�?/p>
Redis参数�Q�代码优化及二次开发基��实践�?/p>
关于作�?/strong>
田琪�Q�目前负责新��微博��^台底层架构与研发工作�Q�之前曾担�Q搜狐白社会实时游戏��^台核心架构工作，主要��x��webgame, 分布式存储，nosql �?erlang �{�领域，目前主要从事mysql源代码的一些深入研�I�工作，��微博：http://weibo.com/bachmozart�?/p>

paulwong 2014-08-26 09:04 发表评论

paulwong — Tue, 19 Aug 2014 01:13:00 GMT
https://github.com/spring-projects/spring-session/tree/master/samples

paulwong 2014-08-19 09:13 发表评论

Redisclient 1.0 发布�Q�Java �?Redis 客户�?GUI 工具

paulwong — Fri, 04 Jul 2014 13:47:00 GMT

redisclient 1.0 正式发布�Q�适用于多�?Redis 版本�Q�主要更新内容如下：
��理 Redis 服务�?/p>
��理 Redis data favorite
��理 Redis 数据
�?Redis 数据�Q�string, list, hash, set, sorted set
重命�?Redis 数据
删除 Redis 数据
更新 Redis 数据
剪切�Q�复�Ӟ��_�脓 Redis 数据
导入�Q�导�?Redis 数据
搜烦 Redis 数据
通过关键字，数据�c�d��Q�大��来排序 Redis 数据
��D��历史
RedisClient �? Redis 客户�?GUI 工具�Q��?Java swt 和jedis �~�写。它��redis数据以windows资源��理器的界面风格呈现�l�用��P��可以帮助redis开发�h员和�l�护人员方便的徏立，修改�Q�删除，查询redis数据�Q�可以让用户方便的编辑数据，可以剪切�Q�拷贝，�_�脓redis数据�Q�可以导入，导出redis数据�Q�可以对redis数据排序�?/p>
https://github.com/caoxinyu/RedisClient

paulwong 2014-07-04 21:47 发表评论

paulwong — Fri, 23 May 2014 04:38:00 GMT

传统MySQL+ Memcached架构遇到的问�?/strong>
　　实际MySQL是适合�q�行��量数据存储的，通过Memcached��热�Ҏ��据加载到cache�Q�加速访问，很多公司都曾�l��用过�q�样的架构，但随着业务数据量的不断增加�Q�和讉K��量的持箋增长�Q�我们遇��C��很多问题�Q?/p>
　　1.MySQL需要不断进行拆库拆表，Memcached也需不断跟着扩容�Q�扩容和�l�护工作占据大量开发时间�?/p>
　　2.Memcached与MySQL数据库数据一致性问题�?/p>
　　3.Memcached数据命中率低或down机，大量讉K��直接�I�K��到DB�Q�MySQL无法支撑�?/p>
　　4.跨机房cache同步问题�?/p>
　　众多NoSQL百花齐放�Q�如何选择
　　最�q�几�q�_��业界不断涌现出很多各�U�各��L��NoSQL产品�Q�那么如何才能正��地使用好这些��品，最大化地发挥其长处�Q�是我们需要深入研�I�和思考的问题�Q�实际归根结底最重要的是了解�q�些产品的定位，�q�且了解到每�ƾ��品的tradeoffs�Q�在实际应用中做到扬镉K��短，��M��上这些NoSQL主要用于解决以下�?�U�问�?/p>
　　1.��量数据存储�Q�高速读写访问。此�c�M�品通过数据全部in-momery 的方式来保证高速访问，同时提供数据落地的功能，实际�q�正是Redis最主要的适用场景�?/p>
　　2.��量数据存储�Q�分布式�pȝ��支持�Q�数据一致性保证，方便的集��节�Ҏ��?删除�?/p>
　　3.�q�方面最具代表性的是dynamo和bigtable 2��论文所阐述的思�\。前者是一个完全无中心的设计，节点之间通过gossip方式传递集��信息，数据保证最�l�一致性，后者是一个中心化的方案设计，通过�c�M��一个分布式锁服务来保证��Z��致�?数据写入先写内存和redo log�Q�然后定期compat归�ƈ到磁盘上�Q�将随机写优化�ؓ��序写，提高写入性能�?/p>
　　4.Schema free�Q�auto-sharding�{�。比如目前常见的一些文档数据库都是支持schema-free的，直接存储json格式数据�Q��ƈ且支持auto-sharding�{�功能，比如mongodb�?/p>
　　面对�q�些不同�c�d��的NoSQL产品,我们需要根据我们的业务场景选择最合适的产品�?/p>
　　Redis适用场景�Q�如何正��的使用
　　前面已经分析�q�，Redis最适合所有数据in-momory的场景，虽然Redis也提供持久化功能�Q�但实际更多的是一个disk-backed的功能，跟传�l�意义上的持久化有比较大的差别，那么可能大家��׃��有疑问，��g��Redis更像一个加强版的Memcached�Q�那么何时��?Memcached,何时使用Redis�?

如果��单地比较Redis与Memcached的区别，大多数都会得��C��下观点：

1 Redis不仅仅支持简单的k/v�c�d��的数据，同时�q�提供list�Q�set�Q�zset�Q�hash�{�数据结构的存储�?br style="padding: 0px; margin: 0px;" />
2 Redis支持数据的备份，即master-slave模式的数据备份�?br style="padding: 0px; margin: 0px;" />
3 Redis支持数据的持久化�Q�可以将内存中的数据保持在磁盘中�Q�重启的时候可以再�ơ加载进行��用�?br style="padding: 0px; margin: 0px;" />
抛开�q�些�Q�可以深入到Redis内部构造去观察更加本质的区别，理解Redis的设计�?br style="padding: 0px; margin: 0px;" />
在Redis中，�q�不是所有的数据都一直存储在内存中的。这是和Memcached相比一个最大的区别。Redis只会�~�存所有的 key的信息，如果Redis发现内存的��用量��过了某一个阀��|��触发swap的操作，Redis�Ҏ��“swappability = age*log(size_in_memory)”�?��出哪些key对应的value需要swap到磁盘。然后再��这些key对应的value持久化到��盘中，同时在内存中清除。这�U�特性��得Redis可以保持��过其机器本�w�内存大��的数据。当�Ӟ��机器本��n的内存必��要能够保持所有的key�Q�毕竟这些数据是不会�q�行swap操作的。同时由于Redis��内�?中的数据swap到磁盘中的时候，提供服务的主�U�程和进行swap操作的子�U�程会共享这部分内存�Q�所以如果更新需要swap的数据，Redis��阻塞这�?操作�Q�直到子�U�程完成swap操作后才可以�q�行修改�?br style="padding: 0px; margin: 0px;" />
使用Redis�Ҏ��内存模型前后的情况对比：
VM off: 300k keys, 4096 bytes values: 1.3G used
VM on: 300k keys, 4096 bytes values: 73M used
VM off: 1 million keys, 256 bytes values: 430.12M used
VM on: 1 million keys, 256 bytes values: 160.09M used
VM on: 1 million keys, values as large as you want, still: 160.09M used

�?从Redis中读取数据的时候，如果��d��的key对应的value不在内存中，那么Redis��需要从swap文�g中加载相应数据，然后再返回给��h��斏V�?�q�里��存在一个I/O�U�程池的问题。在默认的情况下�Q�Redis会出现阻塞，卛_��成所有的swap文�g加蝲后才会相应。这�U�策略在客户端的数量较小�Q�进�?扚w��操作的时候比较合适。但是如果将Redis应用在一个大型的�|�站应用�E�序中，�q�显然是无法满��大�ƈ发的情况的。所以Redis�q�行我们讄��I/O�U�程池的大小�Q�对需要从swap文�g中加载相应数据的��d��h��q�行�q�发操作�Q�减��阻塞的旉��?br style="padding: 0px; margin: 0px;" />
如果希望在�v量数据的环境中��用好Redis�Q�我�怿�理解Redis的内存设计和��d��的情冉|��不可�~�少的�?/p>

补充的知识点�Q?/strong>
memcached和redis的比�?/p>
1 �|�络IO模型
　　Memcached是多�U�程�Q�非��d��IO复用的网�l�模型，分�ؓ监听�ȝ��E�和worker子线�E�，监听�U�程监听�|�络�q�接�Q�接受请求后�Q�将�q�接描述�?pipe 传递给worker�U�程�Q�进行读写IO, �|�络层��用libevent��装的事件库�Q�多�U�程模型可以发挥多核作用�Q�但是引入了cache coherency和锁的问题，比如�Q�Memcached最常用的stats 命��o�Q�实际Memcached所有操作都要对�q�个全局变量加锁�Q�进行计数等工作�Q�带来了性能损耗�?/p>
(Memcached�|�络IO模型)
　　Redis使用单线�E�的IO复用模型�Q�自己封装了一个简单的AeEvent事�g处理框架�Q�主要实��C��epoll、kqueue和select�Q�对于单�U?只有IO操作来说�Q�单�U�程可以��速度优势发挥到最大，但是Redis也提供了一些简单的计算功能�Q�比如排序、聚合等�Q�对于这些操作，单线�E�模型实际会严重影响整体吞吐量，CPU计算�q�程中，整个IO调度都是被阻塞住的�?/p>
　　2.内存��理斚w��
　　Memcached使用预分配的内存池的方式�Q��用slab和大��不同的chunk来管理内存，Item�Ҏ��大小选择合适的chunk存储�Q�内存池的方式可以省�ȝ��?释放内存的开销�Q��ƈ且能减小内存��片产生�Q�但�q�种方式也会带来一定程度上的空间浪费，�q�且在内存仍然有很大�I�间�Ӟ��新的数据也可能会被剔除，原因可以参考Timyang的文章：http://timyang.net/data/Memcached-lru-evictions/
　　Redis使用现场甌��内存的方式来存储数据�Q��ƈ且很��用free-list�{�方式来优化内存分配�Q�会在一定程度上存在内存��片�Q�Redis跟据存储命��o参数�Q�会把带�q�期旉��的数据单独存攑֜�一��P��q�把它们�U�Cؓ临时数据�Q�非临时数据是永�q�不会被剔除的，即便物理内存不够�Q�导致swap也不会剔除�Q何非临时数据(但会��试剔除部分临时数据)�Q�这点上Redis更适合作�ؓ存储而不是cache�?/p>
　　3.数据一致性问�?/p>
　　Memcached提供了cas命��o�Q�可以保证多个�ƈ发访问操作同一份数据的一致性问题�?Redis没有提供cas 命��o�Q��ƈ不能保证�q�点�Q�不�q�Redis提供了事务的功能�Q�可以保证一�?命��o的原子性，中间不会被�Q何操作打断�?/p>
　　4.存储方式及其它方�?/p>
　　Memcached基本只支持简单的key-value存储�Q�不支持枚�D�Q�不支持持久化和复制�{�功�?/p>
　　Redis除key/value之外�Q�还支持list,set,sorted set,hash�{�众多数据结构，提供了KEYS
　　�q�行枚�D操作�Q�但不能在线上��用，如果需要枚丄��上数据，Redis提供了工具可以直接扫描其dump文�g�Q�枚丑և�所有数据，Redis�q�同时提供了持久化和复制�{�功能�?/p>
　　5.关于不同语言的客��L��支持
　　在不同语�a�的客��L��斚w��Q�Memcached和Redis都有丰富的第三方客户端可供选择�Q�不�q�因为Memcached发展的时间更久一些，目前看在�?��L��支持斚w��Q�Memcached的很多客��L��更加成熟�E�_��Q�而Redis�׃��其协议本�w�就比Memcached复杂�Q�加上作者不断增加新的功能等�Q�对�?�W�三方客��L��跟进速度可能会赶不上�Q�有时可能需要自己在�W�三方客��L��基础上做些修�Ҏ��能更好的使用�?/p>
　　�Ҏ��以上比较不难看出�Q�当我们不希望数据被�t�出�Q�或者需要除key/value之外的更多数据类型时�Q�或者需要落地功能时�Q��用Redis比��用Memcached更合适�?/p>
　　关于Redis的一些周边功�?/strong>
　　Redis除了作�ؓ存储之外�q�提供了一些其它方面的功能�Q�比如聚合计��、pubsub、scripting�{�，对于此类功能需要了解其实现原理�Q�清楚地了解到它的局限性后�Q�才能正��的使用�Q�比如pubsub功能�Q�这个实际是没有��M��持久化支持的�Q�消�Ҏ��q�接闪断或重�q�之间过来的消息是会全部丢失的，又比如聚合计��和scripting�{�功能受Redis单线�E�模型所限，是不可能辑ֈ�很高的吞吐量的，需要�}慎��用�?/p>
　　�ȝ��来说Redis作者是一位非常勤奋的开发者，可以�l�常看到作者在��试着各种不同的新鲜想法和思�\�Q�针对这些方面的功能��p��求我们需要深入了解后再��用�?/p>
　　�ȝ��Q?/strong>
　　1.Redis使用最��x��式是全部数据in-memory�?/p>
　　2.Redis更多场景是作为Memcached的替代者来使用�?/p>
　　3.当需要除key/value之外的更多数据类型支持时�Q��用Redis更合适�?/p>
　　4.当存储的数据不能被剔除时�Q��用Redis更合适�?/p>

paulwong 2014-05-23 12:38 发表评论

Redis与Memcached的区�?�?

paulwong — Fri, 06 Sep 2013 03:12:00 GMT
如果��单地比较Redis与Memcached的区别，大多数都会得��C��下观点：
1 Redis不仅仅支持简单的k/v�c�d��的数据，同时�q�提供list�Q�set�Q�hash�{�数据结构的存储�?br />2 Redis支持数据的备份，即master-slave模式的数据备份�?br />3 Redis支持数据的持久化�Q�可以将内存中的数据保持在磁盘中�Q�重启的时候可以再�ơ加载进行��用�?br />
在Redis中，�q�不是所有的数据都一直存储在内存中的。这是和Memcached相比一个最大的区别�Q�我个�h是这么认为的�Q��?br />
Redis只会�~�存所有的key的信息，如果Redis发现内存的��用量��过了某一个阀��|��触发swap的操作，Redis�Ҏ��“swappability = age*log(size_in_memory)”计算出哪些key对应的value需要swap到磁盘。然后再��这些key对应的value持久化到��盘中，同时在内存中清除。这�U�特性��得Redis可以保持��过其机器本�w�内存大��的数据。当�Ӟ��机器本��n的内存必��要能够保持所有的key�Q�毕竟这些数据是不会�q�行swap操作的�?br />
同时�׃��Redis��内存中的数据swap到磁盘中的时候，提供服务的主�U�程和进行swap操作的子�U�程会共享这部分内存�Q�所以如果更新需要swap的数据，Redis��阻塞这个操作，直到子线�E�完成swap操作后才可以�q�行修改�?br />
可以参考��用Redis�Ҏ��内存模型前后的情况对比：

VM off: 300k keys, 4096 bytes values: 1.3G used
VM on: 300k keys, 4096 bytes values: 73M used
VM off: 1 million keys, 256 bytes values: 430.12M used
VM on: 1 million keys, 256 bytes values: 160.09M used
VM on: 1 million keys, values as large as you want, still: 160.09M used

当从Redis中读取数据的时候，如果��d��的key对应的value不在内存中，那么Redis��需要从swap文�g中加载相应数据，然后再返回给��h��斏V��这里就存在一个I/O�U�程池的问题。在默认的情况下�Q�Redis会出现阻塞，卛_��成所有的swap文�g加蝲后才会相应。这�U�策略在客户端的数量较小�Q�进行批量操作的时候比较合适。但是如果将Redis应用在一个大型的�|�站应用�E�序中，�q�显然是无法满��大�ƈ发的情况的。所以Redis�q�行我们讄��I/O�U�程池的大小�Q�对需要从swap文�g中加载相应数据的��d��h��q�行�q�发操作�Q�减��阻塞的旉��?br />
redis、memcache、mongoDB �Ҏ��
从以下几个维度，对redis、memcache、mongoDB 做了�Ҏ��Q�欢�q�拍�?br />
1、性能
都比较高�Q�性能�Ҏ��们来说应该都不是瓉��
��M��来讲�Q�TPS斚w��redis和memcache差不多，要大于mongodb

2、操作的便利�?br />memcache数据�l�构单一
redis丰富一些，数据操作斚w��Q�redis更好一些，较少的网�l�IO�ơ数
mongodb支持丰富的数据表达，索引�Q�最�c�M��关系型数据库�Q�支持的查询语言非常丰富

3、内存空间的大小和数据量的大��?br />redis�?.0版本后增加了自己的VM�Ҏ��，�H�破物理内存的限�Ӟ��可以对key value讄��q�期旉��Q�类似memcache�Q?br />memcache可以修改最大可用内�?采用LRU��法
mongoDB适合大数据量的存储，依赖操作�pȝ��VM做内存管理，吃内存也比较厉害�Q�服务不要和别的服务在一�?br />
4、可用性（单点问题�Q?br />
对于单点问题�Q?br />redis�Q�依赖客��L��来实现分布式��d��Q�主从复制时�Q�每�ơ从节点重新�q�接主节炚w��要依赖整个快�?无增量复�Ӟ��因性能和效率问题，
所以单炚w��题比较复杂；不支持自动sharding,需要依赖程序设定一致hash 机制�?br />一�U�替代方案是�Q�不用redis本��n的复制机�Ӟ��采用自己做主动复�Ӟ��多䆾存储�Q�，或者改成增量复制的方式�Q�需要自己实玎ͼ��Q�一致性问题和性能的权�?br />
Memcache本��n没有数据冗余机制�Q�也没必要；对于故障预防�Q�采用依赖成熟的hash或者环状的��法�Q�解军_��Ҏ��障引��L��抖动问题�?br />
mongoDB支持master-slave,replicaset�Q�内部采用paxos选�D��法�Q�自动故障恢复）,auto sharding机制�Q�对客户端屏蔽了故障转移和切分机制�?br />

5、可靠性（持久化）

对于数据持久化和数据恢复�Q?br />
redis支持�Q�快照、AOF�Q�：依赖快照�q�行持久化，aof增强了可靠性的同时�Q�对性能有所影响

memcache不支持，通常用在做缓�?提升性能�Q?br />
MongoDB�?.8版本开始采用binlog方式支持持久化的可靠�?br />

6、数据一致性（事务支持�Q?br />
Memcache 在�ƈ发场景下�Q�用cas保证一致�?br />
redis事务支持比较弱，只能保证事务中的每个操作�q�箋执行

mongoDB不支持事�?br />

7、数据分�?br />
mongoDB内置了数据分析的功能(mapreduce),其他不支�?br />

8、应用场�?br />redis�Q�数据量较小的更性能操作和运��上

memcache�Q�用于在动态系�l�中减少数据库负载，提升性能;做缓存，提高性能�Q�适合��d��写少�Q�对于数据量比较大，可以采用sharding�Q?br />
MongoDB:主要解决��量数据的访问效率问�?img src ="http://www.aygfsteel.com/paulwong/aggbug/403746.html" width = "1" height = "1" />

paulwong 2013-09-06 11:12 发表评论

REDIS资源

paulwong — Sun, 01 Sep 2013 05:21:00 GMT
R利剑NoSQL�p�d��文章 �?MongoDB
http://cos.name/2013/04/nosql-r-redis/

REDIS书籍
http://abcfy2.gitbooks.io/redis-in-action-reading-notes/getting_to_know_redis/session1.html

paulwong 2013-09-01 13:21 发表评论