博客园_小寒的blog

largest remainder method java impl

2012-01-23T06:01:00Z

/**
* 最大余数分摊算法
* @author xhan
*{@link=http://en.wikipedia.org/wiki/Largest_remainder_method}
*/
public class ShareCalculator {

    public static  double[] calculate(double[] votes , double totalSeats) {
        double[] seats = new double[votes.length];
        double[] reminders = new double[votes.length];

        double totalVotes = 0;
        for (double vote : votes) {
            totalVotes += vote;
        }

        double hareQuota = totalVotes / totalSeats ;
        double allocatedSeats = 0;

        for(int i = 0; i < votes.length ;i++) {
            double voteDivHareQuota = votes[i] / hareQuota;
            seats[i] = Math.floor(voteDivHareQuota);
            reminders[i] = voteDivHareQuota - seats[i];
            allocatedSeats += seats[i];
        }

        double leftSeats = totalSeats - allocatedSeats;

        //allocate left seats to party with largest reminder
        for (int i = 0; i < leftSeats; i++) {
            double max = 0;
            int maxIndex = 0;
            for (int j = 0; j < reminders.length; j++) {
                if(reminders[j] > max) {
                    max = reminders[j];
                    maxIndex = j;
                }
            }
            seats[maxIndex] += 1;
            reminders[maxIndex] = 0;
        }

        return seats;
    }
}

本文链接

数据库单元测试

2011-09-22T14:40:00Z

package com.hichina.bc.repository.test;

import junit.framework.Assert;

import org.hibernate.SessionFactory;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.hichina.bc.domain.Customer;

import com.hichina.bc.repository.CustomerRepository;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations = {"classpath:dispatcher-servlet.xml"})

public class CustomerRepositoryTest {

@Autowired

private SessionFactory sessionFactory;

@Autowired

private CustomerRepository customerRepository;

@Test

public void testInsert() {

sessionFactory.openSession()

.createSQLQuery("truncate table CustomerTest").executeUpdate();

sessionFactory.openSession()

.createSQLQuery("insert into CustomerTest (name,password) values ('aa','bb')")

.executeUpdate();

Customer customer = customerRepository.getById(1);

Assert.assertNotNull(customer);

}

@Test

public void testSave() {

Customer customer = new Customer();

customer.setName("xhan");

customer.setPassword("13");

customerRepository.save(customer);

System.out.println(customer.getUserId());

Assert.assertTrue(customer.getUserId() != 0);

}

@Test

public void testUpdate() {

Customer customer = new Customer();

customer.setName("xhan");

customer.setPassword("13");

customerRepository.save(customer);

Assert.assertTrue(customer.getUserId() != 0);

customer.setName("123");

customer.setPassword("xhan");

customerRepository.update(customer);

Customer customer2 = customerRepository.getById(customer.getUserId());

Assert.assertEquals("xhan", customer2.getPassword());

Assert.assertNotSame(customer, customer2);

}

本文链接

元数据编程实战_使用Emit运行时生成Protobuf编码类

2011-04-02T17:16:00Z

protobuf是google的一种序列化对象的编码方式。相比xml和json的序列化方式,protobuf序列化的结果更小，而且序列化的速度也更快。
本文简单介绍写如果通过Emit来在运行时动态的生成对数据对象的protebuf编码解码类。通过本实例展示下元数据编程的能力。
关于protebuf的编码原理可以参考这里http://code.google.com/intl/zh-CN/apis/protocolbuffers/docs/encoding.html

，本文只展示对简单的int32进行varint方式编码和string的编码,。在此基础上可以很容易的实现全部的protobuf的编码逻辑。首先定义两个用于测试的实体类。

       [ProtoContract]
        public class TestModel1
        {
            [ProtoMember(1)]
            public int UserId { get; set; }
            [ProtoMember(2)]
            public string Password { get; set; }

            [ProtoMember(3)]
            public TestModel2 Model2 { get; set; }

            [ProtoMember(4)]
            public List<TestModel2> Models { get; set; }

        }
        [ProtoContract]
        public class TestModel2
        {
            [ProtoMember(1)]
            public int Id { get; set; }
            [ProtoMember(2)]
            public string Name { get; set; }
        }

这里同时定义了两个attribute用于表明类支持序列化，和那些属性参与序列化，然后定义一个编码解码的接口

    public interface ICodec<T>
    {
        byte[] Encode(T obj);
        T Decode(byte[] data);
    }

我们将在运行时为每个用到的Model生成一个实现ICodec接口的编码类。比如对TestModel1将成才如下签名的一个类

class TestModel1Codec:ICodec<TestModel1> {....}

首先对我们先看看一个手工写的对TestModel1和TestModel2进行编码的Codec类是如何实现的

class TestModel1Codec : ICodec<TestModel1>
        {

            public byte[] Encode(TestModel1 obj)
            {
                ProtoStream stream = new ProtoStream();
                if (obj.UserId != 0)
                {
                    stream.WriteTag(new Tag(1, WireType.Varint));
                    stream.WriteInt32(obj.UserId);
                }
                if (obj.Password != null)
                {
                    stream.WriteTag(new Tag(2, WireType.LengthDelimited));
                    stream.WriteString(obj.Password);
                }
                if (obj.Model2 != null)
                {
                    stream.WriteTag(new Tag(3, WireType.LengthDelimited));
                    stream.WriteBytes(Codec<TestModel2>.Encode(obj.Model2));
                }
                if (obj.Models != null)
                {
                    for (int i = 0; i < obj.Models.Count; i++ )
                    {
                        stream.WriteTag(new Tag(4, WireType.LengthDelimited));
                        stream.WriteBytes(Codec<TestModel2>.Encode(obj.Models[i]));
                    }

                }

                return stream.ToArray();
            }
            public TestModel1 Decode(byte[] data)
            {
                TestModel1 result = new TestModel1();
                ProtoStream stream = new ProtoStream(data);

                while (true)
                {
                    Tag tag = stream.ReadTag();
                    if (tag.Number == -1)
                    {
                        break;
                    }
                    if (tag.Number == 1)
                    {
                        result.UserId = stream.ReadInt32();
                    }
                    if (tag.Number == 2)
                    {
                        result.Password = stream.ReadString();
                    }
                    if (tag.Number == 3)
                    {
                        result.Model2 = Codec<TestModel2>.Decode(stream.ReadBytes());
                    }
                    if (tag.Number == 4)
                    {
                        if (result.Models == null)
                        {
                            result.Models = new List<TestModel2>();
                        }

                        result.Models.Add(Codec<TestModel2>.Decode(stream.ReadBytes()));
                    }
                }

                return result;
            }

        }

        class TestModel2Codec : ICodec<TestModel2>
        {

            public byte[] Encode(TestModel2 obj)
            {
                ProtoStream stream = new ProtoStream();
                if (obj.Id != 0)
                {
                    stream.WriteTag(new Tag(1, WireType.Varint));
                    stream.WriteInt32(obj.Id);
                }
                if (obj.Name != null)
                {
                    stream.WriteTag(new Tag(2, WireType.LengthDelimited));
                    stream.WriteString(obj.Name);
                }

                return stream.ToArray();
            }
            public TestModel2 Decode(byte[] data)
            {
                Program.TestModel2 result = new Program.TestModel2();
                ProtoStream stream = new ProtoStream(data);

                while (true)
                {
                    Tag tag = stream.ReadTag();
                    if (tag.Number == -1)
                    {
                        break;
                    }
                    if (tag.Number == 1)
                    {
                        result.Id = stream.ReadInt32();
                    }
                    if (tag.Number == 2)
                    {
                        result.Name = stream.ReadString();
                    }
                }

                return result;
            }

        }

发现了没，两个Codec类的实现如此相似，并且每个实现的内部if块也很有规律。下面就是通过Emit在运行时的生成Codec的代码例子

public class CodecTypeGenerator
    {
        private static AssemblyBuilder codecAssmblyBuilder = System.AppDomain.CurrentDomain
            .DefineDynamicAssembly(new AssemblyName { Name = "Codec" }, AssemblyBuilderAccess.RunAndSave);

        private static ModuleBuilder codecModuleBuilder = codecAssmblyBuilder.DefineDynamicModule("Codec", "Codec.dll");

        public static Type CreateCodec<T>()
        {
            Type messageType = typeof(T);
            TypeBuilder typeBuilder = codecModuleBuilder.DefineType(messageType.Name + "Codec",
                TypeAttributes.Class | TypeAttributes.Public);

            typeBuilder.AddInterfaceImplementation(typeof(ICodec<T>));

            MethodBuilder encodeMethodBuilder = typeBuilder
                .DefineMethod("Encode", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual,
                CallingConventions.Standard,typeof(byte[]),new  Type[]{ typeof(T)}
                );

            MethodBuilder decodeMethodBuilder = typeBuilder
                .DefineMethod("Decode", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, CallingConventions.Standard, typeof(T), new Type[]

{ typeof(byte[]) });

            ILGenerator encodeMethodBody = encodeMethodBuilder.GetILGenerator();

            CreateEncodeMethodBody(encodeMethodBody, messageType);

            ILGenerator decodeMethodBody = decodeMethodBuilder.GetILGenerator();
            CreateDecodeMethodBody(decodeMethodBody, messageType);

            return typeBuilder.CreateType();

        }
        private static ConstructorInfo tagConstructor = typeof(Tag).GetConstructor(new Type[2] { typeof(int), typeof(WireType) });
        private static ConstructorInfo proteStreamConstructorWithArgs = typeof(ProtoStream).GetConstructor(new Type[1] { typeof(byte[]) });
        private static ConstructorInfo proteStreamDefaultConstructor = typeof(ProtoStream).GetConstructor(new Type[0]);

        private static MethodInfo writeTagMethod = typeof(ProtoStream).GetMethod("WriteTag");
        private static MethodInfo writeInt32Method = typeof(ProtoStream).GetMethod("WriteInt32");
        private static MethodInfo writeStringMethod = typeof(ProtoStream).GetMethod("WriteString");
        private static MethodInfo toArrayMethod = typeof(ProtoStream).GetMethod("ToArray");
        private static MethodInfo writeBytesMethod = typeof(ProtoStream).GetMethod("WriteBytes");

        private static void CreateEncodeMethodBody(ILGenerator il, Type messageType)
        {
            il.DeclareLocal(typeof(ProtoStream));
            il.DeclareLocal(typeof(Tag));
            il.DeclareLocal(typeof(byte[]));

            //stream = new ProtoStream();
            il.Emit(OpCodes.Newobj, proteStreamDefaultConstructor);
            il.Emit(OpCodes.Stloc_0);

            //
            foreach (var p in messageType.GetProperties())
            {
                if (p.IsDefined(typeof(ProtoMemberAttribute), false))
                {
                    ProtoMemberAttribute protoMember = p.GetCustomAttributes(false)[0] as ProtoMemberAttribute;
                    if (p.PropertyType == typeof(int))
                    {
                        //if(value != 0) { write(value) }
                        Label skipLabel = il.DefineLabel();
                        il.Emit(OpCodes.Ldarg_1);
                        il.Emit(OpCodes.Call, p.GetGetMethod());
                        il.Emit(OpCodes.Brfalse, skipLabel);

                        //write tag
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldc_I4, protoMember.TagNumber);
                        il.Emit(OpCodes.Ldc_I4_0);
                        il.Emit(OpCodes.Newobj, tagConstructor);
                        il.Emit(OpCodes.Call, writeTagMethod);

                        //write int value
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldarg_1);
                        il.Emit(OpCodes.Call, p.GetGetMethod());
                        il.Emit(OpCodes.Call, writeInt32Method);

                        il.MarkLabel(skipLabel);
                    }
                    if (p.PropertyType == typeof(string))
                    {
                        Label skipLabel = il.DefineLabel();
                        //if(str != null) { write str}
                        il.Emit(OpCodes.Ldarg_1);
                        il.Emit(OpCodes.Call, p.GetGetMethod());
                        il.Emit(OpCodes.Brfalse, skipLabel);

                        //write tag
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldc_I4, protoMember.TagNumber);
                        il.Emit(OpCodes.Ldc_I4_2);
                        il.Emit(OpCodes.Newobj, tagConstructor);
                        il.Emit(OpCodes.Call, writeTagMethod);

                        //write string value
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldarg_1);
                        il.Emit(OpCodes.Call, p.GetGetMethod());
                        il.Emit(OpCodes.Call, writeStringMethod);

                        il.MarkLabel(skipLabel);
                    }
                    if (p.PropertyType.IsDefined(typeof(ProtoMessageAttribute), false))
                    {
                    .......                    }
                }

            }

            //return stream.ToArray()
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Call, toArrayMethod);
            il.Emit(OpCodes.Ret);

        }

        private static MethodInfo getTagNumberMethod = typeof(Tag).GetProperty("Number").GetGetMethod();

        private static MethodInfo readTagMethod = typeof(ProtoStream).GetMethod("ReadTag");
        private static MethodInfo readInt32Method = typeof(ProtoStream).GetMethod("ReadInt32");
        private static MethodInfo readStringMethod = typeof(ProtoStream).GetMethod("ReadString");
        private static MethodInfo readBytesMethod = typeof(ProtoStream).GetMethod("ReadBytes");

        private static void CreateDecodeMethodBody(ILGenerator il, Type messageType)
        {
            il.DeclareLocal(messageType); //result
            il.DeclareLocal(typeof(ProtoStream)); //stream
            il.DeclareLocal(typeof(Tag)); // tag
            il.DeclareLocal(typeof(byte[])); //tempData
            Label beginWhile = il.DefineLabel();
            Label endWhile = il.DefineLabel();
            //result = new T()
            il.Emit(OpCodes.Newobj, messageType.GetConstructor(new Type[0]));
            il.Emit(OpCodes.Stloc_0);

            //stream = new ProtoStream(data)
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Newobj, proteStreamConstructorWithArgs);
            il.Emit(OpCodes.Stloc_1);

            il.MarkLabel(beginWhile);
            //if(tag.TagNumber == -1) break;
            il.Emit(OpCodes.Ldloc_1);
            il.Emit(OpCodes.Call, readTagMethod);
            il.Emit(OpCodes.Stloc_2);
            il.Emit(OpCodes.Ldloc_2);
            il.Emit(OpCodes.Call, getTagNumberMethod);
            il.Emit(OpCodes.Ldc_I4_M1);
            il.Emit(OpCodes.Beq, endWhile);

            foreach (var p in messageType.GetProperties())
            {
                if (p.IsDefined(typeof(ProtoMemberAttribute), false))
                {
                    ProtoMemberAttribute protoMember = p.GetCustomAttributes(false)[0] as ProtoMemberAttribute;

                    Label skipLabel = il.DefineLabel();
                    il.Emit(OpCodes.Ldloc_2);
                    il.Emit(OpCodes.Call, getTagNumberMethod);
                    il.Emit(OpCodes.Ldc_I4, protoMember.TagNumber);
                    il.Emit(OpCodes.Bne_Un, skipLabel);

                    if (p.PropertyType == typeof(int))
                    {
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldloc_1);
                        il.Emit(OpCodes.Call, readInt32Method);
                        il.Emit(OpCodes.Call, p.GetSetMethod());
                    }
                    if (p.PropertyType == typeof(string))
                    {
                        il.Emit(OpCodes.Ldloc_0);
                        il.Emit(OpCodes.Ldloc_1);
                        il.Emit(OpCodes.Call, readStringMethod);
                        il.Emit(OpCodes.Call, p.GetSetMethod());
                    }
                    if (p.PropertyType.IsDefined(typeof(ProtoMessageAttribute), false))
                    {
                 .......                    }
                    il.MarkLabel(skipLabel);

                }
            }
            il.Emit(OpCodes.Br, beginWhile);
            il.MarkLabel(endWhile);

            //return result
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Ret);
        }

        public static void Save()
        {
            codecAssmblyBuilder.Save("Codec.dll");
        }

    }

首先不要被il代码给吓住，其实很容易实现的，你只要将手工写的两个实现，通过ildasm工具打开，大部分的指令可以现成的照抄就行了
然后就是运用一点反射来查看元数据信息，并将重复il片段写到for循环中就ok了。调试的时候如果发现有什么异常，可以通过Save方法，把动态创建的assembly写到磁盘上
然后ildasm打开或者用reflector(现在不是免费的了，不过可以试用)和手工写的反汇编代码对比着查看，很容易能找到问题。ProtoStream ,Tag类是具体对protobuf编码算法的一个封装。

最后在封装一个factory类来简化对Codec类的实例创建

    public class Codec<T>
    {
        static ICodec<T> codec = (ICodec<T>)Activator.CreateInstance(CodecTypeGenerator.CreateCodec<T>());

        public static byte[] Encode(T obj)
        {
            return codec.Encode(obj);
        }
        public static T Decode(byte[] data)
        {
            return codec.Decode(data);
        }
    }

然后写个简单的小测试

        static void Main(string[] args)
        {

            byte[] data = Codec<TestModel1>.Encode(new TestModel1
            {
                UserId = 11,
                Password = "fetion123",
                Model2 = new TestModel2 { Id = 4, Name = "test" },
                Models = new List<TestModel2> { new TestModel2 { Id = 5, Name = "asdfasfd" },
                    new TestModel2 { Id = 4, Name = "vvv" } }
            });

            TestModel1 aa = Codec<TestModel1>.Decode(data);

            Console.WriteLine(aa.Model2.Name);

            Console.ReadKey();

            CodecTypeGenerator.Save();

        }

一切ok,睡觉去！本文主要是演示emit。proto编码算法的代码有兴趣的可以在附近中找到！/Files/xhan/Protobuf.rar

本文链接

发布个c#版的HandlerSocket客户端类库

2011-03-24T10:22:00Z

HandlerSocket 是一个mysql 数据库的插件，它可以绕过mysql的查询分析和优化的过程，直接与innodb存储引擎进行交互。尤其是当大多数数据都被innodb缓存到内存中的时候，

查询分析和优化过程就会是整个查询处理过程的瓶颈。通过使用HandlerSocket可以绕过这个瓶颈，从而提升性能。这要比mysql+memched要有优势，因为HandlerSocket不需要处理缓存失效的问题。下面看下HsClient访问mysql的一个例子代码

1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using HsClient;
6
7 namespace HsClientTest
8 {
9     class Program
10     {
11         private static HsIndexSessionFactory client = new HsIndexSessionFactory("192.168.200.9", 9999);
12         static void Main(string[] args)
13         {
14             HsIndexSession session = null;
15             try
16             {
17                 session = client.OpenIndex(0, "test", "FUser", "PRIMARY",
18                     new string[] { "UserId", "Nickname", "Email" });
19
20                 HsResultSet rs = session.Find(HsOperator.GreatEqual, new string[] { "0" }, 20, 0);
21
22                 while (rs.Next())
23                 {
24                     Console.WriteLine("id:{0},nickname:{1},email:{2}", rs.GetInt(0), rs.GetString(1), rs.GetString(2));
25                 }
26
27                 int count = session.Update(HsOperator.Equal, new string[] { "6" }, 1, 0, new string[] { "6", "c#", "x@x.net" });
28                 Console.WriteLine("update count {0}", count);
29
30
31                 count = session.Delete(HsOperator.Equal, new string[] { "6" }, 1, 0);
32                 Console.WriteLine("delete count {0}", count);
33
34
35                 bool insertResult = session.Insert(new string[] { "6", "haha", "you@aa.ss" });
36                 Console.WriteLine("insert success {0}", insertResult);
37             }
38             finally
39             {
40                 if (session != null)
41                 {
42                     session.Close();
43                 }
44             }
45
46
47             //close all socket in the end
48             client.Shutdown();
49             Console.ReadKey();
50         }
51     }
52 }

要访问mysql必须首先打开一个IndexSession.指明我们要访问的索引名称和要访问的字段。很容易理解，因为没有了mysql原来的查询分析和优化。所以访问表数据使用那个索引

就必须我们自己来选择。注意通过IndexSession发起的CRUD操作的字段数量很顺序必须和打开IndexSession时提供的字段是一样的。使用完IndexSession要记得关闭，关闭会吧IndexSession使用的Socket连接，交还给连接池。最后Shutdown操作会关闭连接池中所有连接.

下载/Files/xhan/HsClient.rar 源代码也就500行左右，学习网络编程的同学可以看看。

https://github.com/ahiguti/HandlerSocket-Plugin-for-MySQL/blob/master/docs-en/protocol.en.txt

代码还没经过生产环境测试，慎重使用，仅供学习交流

本文链接

redis入门系列文章广告贴

2011-02-08T05:36:00Z

放假没事学习了redis这个key-value数据库。顺便写了点学习笔记和大家分享下，希望对想了解redis的同学有所帮助。

九 redis学习笔记之虚拟内存

2011-02-07T11:49:00Z

        首先说明下redis的虚拟内存与os的虚拟内存不是一码事，但是思路和目的都是相同的。就是暂时把不经常访问的数据从内存交换到磁盘中，从而腾出宝贵的内存空间用于其他需要访问的数据。尤其是对于redis这样的内存数据库，内存总是不够用的。除了可以将数据分割到多个redis server外。另外的能够提高数据库容量的办法就是使用vm把那些不经常访问的数据交换的磁盘上。如果我们的存储的数据总是有少部分数据被经常访问，大部分数据很少被访问，对于网站来说确实总是只有少量用户经常活跃。当少量数据被经常访问时，使用vm不但能提高单台redis server数据库的容量，而且也不会对性能造成太多影响。

        redis没有使用os提供的虚拟内存机制而是自己在用户态实现了自己的虚拟内存机制,作者在自己的blog专门解释了其中原因。http://antirez.com/post/redis-virtual-memory-story.html
主要的理由有两点

1.os 的虚拟内存是已4k页面为最小单位进行交换的。而redis的大多数对象都远小于4k，所以一个os页面上可能有多个redis对象。另外redis的集合对象类型如list,set可能存在与多个os页面上。最终可能造成只有10%key被经常访问，但是所有os页面都会被os认为是活跃的，这样只有内存真正耗尽时os才会交换页面。

2.相比于os的交换方式。redis可以将被交换到磁盘的对象进行压缩,保存到磁盘的对象可以去除指针和对象元数据信息。一般压缩后的对象会比内存中的对象小10倍。这样redis的vm会比os vm能少做很多io操作。

下面是vm相关配置
vm-enabled yes                    #开启vm功能
vm-swap-file /tmp/redis.swap                 #交换出来的value保存的文件路径/tmp/redis.swap
vm-max-memory 1000000                  #redis使用的最大内存上限，超过上限后redis开始交换value到磁盘文件中。
vm-page-size 32                    #每个页面的大小32个字节
vm-pages 134217728                 #最多使用在文件中使用多少页面,交换文件的大小 = vm-page-size * vm-pages
vm-max-threads 4                    #用于执行value对象换入换出的工作线程数量。0表示不使用工作线程（后面介绍)

       redis的vm在设计上为了保证key的查找速度，只会将value交换到swap文件中。所以如果是内存问题是由于太多value很小的key造成的，那么vm并不能解决。和os一样redis也是按页面来交换对象的。redis规定同一个页面只能保存一个对象。但是一个对象可以保存在多个页面中。在redis使用的内存没超过vm-max-memory之前是不会交换任何value的。当超过最大内存限制后，redis会选择较老的对象。如果两个对象一样老会优先交换比较大的对象，精确的公式swappability = age*log(size_in_memory)。对于vm-page-size的设置应该根据自己的应用将页面的大小设置为可以容纳大多数对象的大小。太大了会浪费磁盘空间，太小了会造成交换文件出现碎片。对于交换文件中的每个页面，redis会在内存中对应一个1bit值来记录页面的空闲状态。所以像上面配置中页面数量(vm-pages 134217728 )会占用16M内存用来记录页面空闲状态。vm-max-threads表示用做交换任务的线程数量。如果大于0推荐设为服务器的cpu core的数量。如果是0则交换过程在主线程进行。

参数配置讨论完后，在来简单介绍下vm是如何工作的，
当vm-max-threads设为0时(Blocking VM)
换出
主线程定期检查发现内存超出最大上限后，会直接已阻塞的方式,将选中的对象保存到swap文件中，并释放对象占用的内存,此过程会一直重复直到下面条件满足
1.内存使用降到最大限制以下
2.swap文件满了
3.几乎全部的对象都被交换到磁盘了

换入
当有client请求value被换出的key时。主线程会以阻塞的方式从文件中加载对应的value对象，加载时此时会阻塞所以client。然后处理client的请求

当vm-max-threads大于0(Threaded VM)
换出
当主线程检测到使用内存超过最大上限，会将选中的要交换的对象信息放到一个队列中交由工作线程后台处理，主线程会继续处理client请求。

换入
如果有client请求的key被换出了，主线程先阻塞发出命令的client,然后将加载对象的信息放到一个队列中，让工作线程去加载。加载完毕后工作线程通知主线程。主线程再执行client的命令。这种方式只阻塞请求value被换出key的client

总的来说blocking vm的方式总的性能会好一些，因为不需要线程同步，创建线程和恢复被阻塞的client等开销。但是也相应的牺牲了响应性。threaded vm的方式主线程不会阻塞在磁盘io上，所以响应性更好。如果我们的应用不太经常发生换入换出，而且也不太在意有点延迟的话则推荐使用blocking vm的方式。关于redis vm的更详细介绍可以参考下面链接
http://antirez.com/post/redis-virtual-memory-story.html
http://redis.io/topics/internals-vm

本文链接

八 redis学习笔记之主从复制

2011-02-07T07:47:00Z

redis主从复制配置和使用都非常简单。通过主从复制可以允许多个slave server拥有和master server相同的数据库副本。下面是关于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上配置数据持久化。

下面介绍下主从复制的过程
当设置好slave服务器后，slave会建立和master的连接，然后发送sync命令。无论是第一次同步建立的连接还是连接断开后的重新连接，master都会启动一个后台进程，将数据库快照保存到文件中，同时master主进程会开始收集新的写命令并缓存起来。后台进程完成写文件后，master就发送文件给slave，slave将文件保存到磁盘上，然后加载到内存恢复数据库快照到slave上。接着master就会把缓存的命令转发给slave。而且后续master收到的写命令都会通过开始建立的连接发送给slave。从master到slave的同步数据的命令和从 client发送的命令使用相同的协议格式。当master和slave的连接断开时slave可以自动重新建立连接。如果master同时收到多个 slave发来的同步连接命令，只会使用启动一个进程来写数据库镜像，然后发送给所有slave。

配置slave服务器很简单，只需要在配置文件中加入如下配置
slaveof 192.168.1.1 6379 #指定master的ip和端口

本文链接

七 redis学习笔记之持久化

2011-02-07T05:34:00Z

      redis是一个支持持久化的内存数据库，也就是说redis需要经常将内存中的数据同步到磁盘来保证持久化。redis支持两种持久化方式，一种是 Snapshotting（快照）也是默认方式，另一种是Append-only file（缩写aof）的方式。下面分别介绍

Snapshotting
       快照是默认的持久化方式。这种方式是就是将内存中数据以快照的方式写入到二进制文件中,默认的文件名为dump.rdb。可以通过配置设置自动做快照持久化的方式。我们可以配置redis在n秒内如果超过m个key被修改就自动做快照，下面是默认的快照保存配置

save 900 1 #900秒内如果超过1个key被修改，则发起快照保存
save 300 10 #300秒内容如超过10个key被修改，则发起快照保存
save 60 10000

下面介绍详细的快照保存过程

1.redis调用fork,现在有了子进程和父进程。

2. 父进程继续处理client请求，子进程负责将内存内容写入到临时文件。由于os的写时复制机制（copy on write)父子进程会共享相同的物理页面，当父进程处理写请求时os会为父进程要修改的页面创建副本，而不是写共享的页面。所以子进程的地址空间内的数据是fork时刻整个数据库的一个快照。

3.当子进程将快照写入临时文件完毕后，用临时文件替换原来的快照文件，然后子进程退出。

client 也可以使用save或者bgsave命令通知redis做一次快照持久化。save操作是在主线程中保存快照的，由于redis是用一个主线程来处理所有 client的请求，这种方式会阻塞所有client请求。所以不推荐使用。另一点需要注意的是，每次快照持久化都是将内存数据完整写入到磁盘一次，并不是增量的只同步脏数据。如果数据量大的话，而且写操作比较多，必然会引起大量的磁盘io操作，可能会严重影响性能。

另外由于快照方式是在一定间隔时间做一次的，所以如果redis意外down掉的话，就会丢失最后一次快照后的所有修改。如果应用要求不能丢失任何修改的话，可以采用aof持久化方式。下面介绍

Append-only file

aof 比快照方式有更好的持久化性，是由于在使用aof持久化方式时,redis会将每一个收到的写命令都通过write函数追加到文件中(默认是 appendonly.aof)。当redis重启时会通过重新执行文件中保存的写命令来在内存中重建整个数据库的内容。当然由于os会在内核中缓存 write做的修改，所以可能不是立即写到磁盘上。这样aof方式的持久化也还是有可能会丢失部分修改。不过我们可以通过配置文件告诉redis我们想要通过fsync函数强制os写入到磁盘的时机。有三种方式如下（默认是：每秒fsync一次）

appendonly yes              //启用aof持久化方式
# appendfsync always      //每次收到写命令就立即强制写入磁盘，最慢的，但是保证完全的持久化，不推荐使用
appendfsync everysec     //每秒钟强制写入磁盘一次，在性能和持久化方面做了很好的折中，推荐
# appendfsync no   //完全依赖os，性能最好,持久化没保证

aof 的方式也同时带来了另一个问题。持久化文件会变的越来越大。例如我们调用incr test命令100次，文件中必须保存全部的100条命令，其实有99条都是多余的。因为要恢复数据库的状态其实文件中保存一条set test 100就够了。为了压缩aof的持久化文件。redis提供了bgrewriteaof命令。收到此命令redis将使用与快照类似的方式将内存中的数据以命令的方式保存到临时文件中，最后替换原来的文件。具体过程如下

1. redis调用fork ，现在有父子两个进程
2. 子进程根据内存中的数据库快照，往临时文件中写入重建数据库状态的命令
3.父进程继续处理client请求，除了把写命令写入到原来的aof文件中。同时把收到的写命令缓存起来。这样就能保证如果子进程重写失败的话并不会出问题。
4.当子进程把快照内容写入已命令方式写到临时文件中后，子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件。
5.现在父进程可以使用临时文件替换老的aof文件，并重命名，后面收到的写命令也开始往新的aof文件中追加。

需要注意到是重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件,这点和快照有点类似。

本文链接

六 redis学习笔记之发布订阅

2011-02-06T06:44:00Z

        发布订阅(pub/sub)是一种消息通信模式，主要的目的是解耦消息发布者和消息订阅者之间的耦合，这点和设计模式中的观察者模式比较相似。pub /sub不仅仅解决发布者和订阅者直接代码级别耦合也解决两者在物理部署上的耦合。redis作为一个pub/sub server，在订阅者和发布者之间起到了消息路由的功能。订阅者可以通过subscribe和psubscribe命令向redis server订阅自己感兴趣的消息类型，redis将消息类型称为通道(channel)。当发布者通过publish命令向redis server发送特定类型的消息时。订阅该消息类型的全部client都会收到此消息。这里消息的传递是多对多的。一个client可以订阅多个 channel,也可以向多个channel发送消息。

下面做个实验。这里使用两个不同的client一个是redis自带的redis-cli另一个是用java写的简单的client。代码如下
import java.net.*;
import java.io.*;
public class PubSubTest {
   public static void main(String[] args) {
       String cmd = args[0]+"\r\n";
       try {
           Socket socket = new Socket("192.168.56.55",6379);
           InputStream in = socket.getInputStream();
           OutputStream out = socket.getOutputStream();
           out.write(cmd.getBytes()); //发送订阅命令
           byte[] buffer = new byte[1024];
           while (true) {
               int readCount =   in.read(buffer);
               System.out.write(buffer, 0, readCount);
               System.out.println("--------------------------------------");
           }
       } catch (Exception e) {
       }
   }
}

代码就是简单的从命令行读取传过来的订阅命令，然后通过一个socket连接发送给redis server,然后进入while循环一直读取redis server传过来订阅的消息。并打印到控制台

1 首先编译并运行此java程序(我是win7下面运行的)
D:\>javac PubSubTest.java
D:\>java PubSubTest "subscribe news.share news.blog"
*3
$9
subscribe
$10
news.share
:1

*3
$9
subscribe
$9
news.blog
:2
--------------------------------------
2 启动redis-cli
redis> psubscribe news.*
Reading messages... (press Ctrl-c to quit)
1. "psubscribe"
2. "news.*"
3. (integer) 1

3 再启动一个redis-cli用来发布两条消息
redis> publish news.share "share a link http://www.google.com"
(integer) 2
redis> publish news.blog "I post a blog"
(integer) 2

4.查看两个订阅client的输出
此时java client打印如下内容
*3
$7
message
$10
news.share
$34
share a link http://www.google.com
--------------------------------------
*3
$7
message
$9
news.blog
$13
I post a blog
--------------------------------------
另一个redis-cli输出如下
1. "pmessage"
2. "news.*"
3. "news.share"
4. "share a link http://www.google.com"

1. "pmessage"
2. "news.*"
3. "news.blog"
4. "I post a blog"

分析下
java client使用subscribe命令订阅news.share和news.blog两个通道，然后立即收到server返回的订阅成功消息，可以看出 redis的协议是文本类型的，这里不解释具体协议内容了，可以参考http://redis.io/topics/protocol或者http://terrylee.me/blog/post/2011/01/26/redis-internal-part3.aspx。这个报文内容有两部分,第一部分表示该socket连接上使用 subscribe订阅news.share成功后，此连接订阅通道数为1，后一部分表示使用subscribe订阅news.blog成功后，该连接订阅通道总数为2。

redis client使用psubscribe订阅了一个使用通配符的通道(*表示任意字符串)，此订阅会收到所有与news.*匹配的通道消息。redis- cli打印到控制台的订阅成功消息表示使用psubscribe命令订阅news.*成功后，连接订阅通道总数为1。

当我们在一个client使用publish 向news.share和news.blog通道发出两个消息后。redis返回的(integer) 2表示有两个连接收到了此消息。通过观察两个订阅者的输出可以验证。具体格式不解释了，都比较简单。

看完一个小例子后应该对pub/sub功能有了一个感性的认识。需要注意的是当一个连接通过subscribe或者psubscribe订阅通道后就进入订阅模式。在这种模式除了再订阅额外的通道或者用unsubscribe或者punsubscribe命令退出订阅模式，就不能再发送其他命令。另外使用 psubscribe命令订阅多个通配符通道，如果一个消息匹配上了多个通道模式的话，会多次收到同一个消息。

jredis目前版本没提供pub/sub支持，不过自己实现一个应该也挺简单的。整个应用程序可以共享同一个连接。因为redis返回的消息报文中除了消息内容本身外还包括消息相关的通道信息，当收到消息后可以根据不同的通道信息去调用不同的callback来处理。

另外个人觉得redis的pub/sub还是有点太单薄（实现才用150行代码）。在安全，认证，可靠性这方便都没有太多支持。

本文链接

五 redis学习笔记之pipeline

2011-02-05T05:48:00Z

redis是一个cs模式的tcp server，使用和http类似的请求响应协议。一个client可以通过一个socket连接发起多个请求命令。每个请求命令发出后client通常会阻塞并等待redis服务处理，redis处理完后请求命令后会将结果通过响应报文返回给client。基本的通信过程如下
Client: INCR X
Server: 1
Client: INCR X
Server: 2
Client: INCR X
Server: 3
Client: INCR X
Server: 4
基本上四个命令需要8个tcp报文才能完成。由于通信会有网络延迟,假如从client和server之间的包传输时间需要0.125秒。那么上面的四个命令8个报文至少会需要1秒才能完成。这样即使redis每秒能处理100个命令，而我们的client也只能一秒钟发出四个命令。这显示没有充分利用 redis的处理能力。除了可以利用mget,mset 之类的单条命令处理多个key的命令外
我们还可以利用pipeline的方式从client打包多条命令一起发出，不需要等待单条命令的响应返回，而redis服务端会处理完多条命令后会将多条命令的处理结果打包到一起返回给客户端。通信过程如下

Client: INCR X
Client: INCR X
Client: INCR X
Client: INCR X
Server: 1
Server: 2
Server: 3
Server: 4

假设不会因为tcp 报文过长而被拆分。可能两个tcp报文就能完成四条命令,client可以将四个incr命令放到一个tcp报文一起发送，server则可以将四条命令的处理结果放到一个tcp报文返回。通过pipeline方式当有大批量的操作时候。我们可以节省很多原来浪费在网络延迟的时间。需要注意到是用 pipeline方式打包命令发送，redis必须在处理完所有命令前先缓存起所有命令的处理结果。打包的命令越多，缓存消耗内存也越多。所以并是不是打包的命令越多越好。具体多少合适需要根据具体情况测试。下面是个jredis客户端使用pipeline的测试
package jredisStudy;
import org.jredis.JRedis;
import org.jredis.connector.ConnectionSpec;
import org.jredis.ri.alphazero.JRedisClient;
import org.jredis.ri.alphazero.JRedisPipelineService;
import org.jredis.ri.alphazero.connection.DefaultConnectionSpec;
public class PipeLineTest {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        usePipeline();
        long end = System.currentTimeMillis();
        System.out.println(end-start);

        start = System.currentTimeMillis();
        withoutPipeline();
        end = System.currentTimeMillis();
        System.out.println(end-start);

    }

    private static void withoutPipeline()
    {
        try {
            JRedis jredis = new JRedisClient("192.168.56.55",6379);
                for(int i =0 ; i < 100000 ; i++)
                {
                    jredis.incr("test2");
                }
                jredis.quit();
        } catch (Exception e) {
        }
    }

    private static void usePipeline() {
        try {
            ConnectionSpec spec = DefaultConnectionSpec.newSpec("192.168.56.55", 6379, 0, null);
            JRedis jredis = new JRedisPipelineService(spec);
            for(int i =0 ; i < 100000 ; i++)
            {
                jredis.incr("test2");
            }
            jredis.quit();
        } catch (Exception e) {
        }
    }
}
输出
103408 //使用了pipeline
104598 //没有使用

测试结果不是很明显，这应该是跟我的测试环境有关。我是在自己win连接虚拟机的linux。网络延迟比较小。所以pipeline
优势不明显。如果网络延迟小的话，最好还是不用pipeline。除了增加复杂外，带来的性能提升不明显。

本文链接